fix: sanitizer checks fix (iteration 3 - final)

fix: sanitizer checks fix (iteration 2)
fix: sanitizer checks fix (iteration 1)
2026-10-19 20:11:48 +03:00 · 2026-10-19 19:54:11 +03:00 · 2026-10-19 19:41:39 +03:00 · 2026-10-19 18:39:40 +03:00 · 2026-10-19 17:50:31 +03:00 · 2026-10-18 18:00:03 +00:00
25 changed files with 755 additions and 303 deletions
@@ -1,8 +1,14 @@
-cmake_minimum_required(VERSION 4.3)
+cmake_minimum_required(VERSION 3.16)
 project(fz-lang
 	LANGUAGES C)

 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+add_compile_options(-Wall -Wextra -Werror=implicit-function-declaration)
+
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+	add_compile_options(-fsanitize=address,undefined -g)
+	add_link_options(-fsanitize=address,undefined)
+endif()

 include_directories(include)

@@ -78,6 +84,10 @@ add_test(
 	NAME compile_borrow
 	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/borrow.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/borrow.fzs"
 )
+add_test(
+	NAME compile_hard_1
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/hard-1.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/hard-1.fzs"
+)

 set_tests_properties(compile_problematic_hw PROPERTIES WILL_FAIL TRUE)

@@ -125,4 +135,8 @@ add_test(
 	NAME runtime_borrow
 	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/borrow.fzb"
 )
+add_test(
+	NAME runtime_hard_1
+	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/hard-1.fzb"
+)

@@ -7,12 +7,11 @@ fn doSome(A a) A
 {
  // NOTE: section below won't change `a.some` value

-  // if (a.some < 1)
-  // {
-  //   a.some = 1;
-  //   return a;
-  // }
-  a.some = 1;
+  if (a.some < 1)
+  {
+    a.some = 1;
+    return a;
+  }

  return a;
 }
@@ -27,11 +26,21 @@ fn doSomeNew() A

 A a = new A;
 a.some = 0;
-printline(a);
+if (a.some != 0)
+{
+  printline("Test failed (first a.some != 0)");
+  exit(1);
+}
+else printline(a);

 a = doSome(a);
-printline(a);
+if (a.some != 1)
+{
+  printline("Test failed (2nd a.some != 1)");
+  exit(1);
+}
+else printline(a);

-b = doSomeNew();
+A b = doSomeNew();
 printline(b);

@@ -28,5 +28,9 @@ printline(obj.y);

 if (obj.x == 10 && obj.y == 10)
  printline("Test passed");
-else printline("Test failed");
+else
+{
+  printline("Test failed");
+  exit(1);
+}

@@ -1,13 +1,17 @@
 bool flag = true;

 if (!flag)
+{
  printline("buhhh, flag is not true");
+  exit(1);
+}
 else if (2 + 2 >= 4)
 {
  printline ("two plus two is four");
 }
 else {
  printline("gotcha");
+  exit(1);
 }

 {
@@ -15,10 +15,18 @@ printline("Test #1: fibonacci");
 int result = fib(7);
 if (result == 13)
  printline("Recurse test passed");
-else printline("Recurse test failed");
+else
+{
+  printline("Recurse test failed");
+  exit(1);
+}

 printline("Test #2: sum");
 if (sum(2, 2) == 4)
  printline("Sum test passed");
-else printline("Sum test failed");
+else
+{
+  printline("Sum test failed");
+  exit(1);
+}

@@ -0,0 +1,66 @@
+class Node
+{
+  int value;
+  Node next;
+
+  fn append(int val) Node
+  {
+    if (this.next == null)
+    {
+      Node tail = new Node;
+      tail.value = val;
+      tail.next = null;
+      this.next = tail;
+      return this;
+    }
+
+    this.next = this.next.append(val);
+    return this;
+  }
+
+  fn sum() int
+  {
+    if (this.next == null)
+      return this.value;
+
+    return this.value + this.next.sum();
+  }
+
+  fn printList()
+  {
+    printline(this.value);
+    if (this.next != null)
+      this.next.printList();
+  }
+}
+
+fn createList(int count) Node
+{
+  if (count <= 0)
+    return null;
+
+  Node head = new Node;
+  head.value = count;
+  head.next = createList(count - 1);
+  return head;
+}
+
+printline("===== Test 1: factory & recursive escaping =====");
+Node list = createList(3);
+printline("Elements:");
+list.printList();
+
+printline("===== Test 2: mutation & methods =====");
+list = list.append(10);
+int total = list.sum();
+printline("Sum of elements:");
+printline(total);
+
+if (total == 16)
+  printline("Tests passed!");
+else
+{
+  printline("Tests failed");
+  exit(1);
+}
+
@@ -21,14 +21,26 @@ a.name = "Buryatka";
 a.age = 5;

 Animal b = a.copy();
-a.name = "Gavryusha";
-a.age = 10;
+b.name = "Gavryusha";
+b.age = 10;

 printline(a);
 printline(b);

+printline("Types are same:");
+printline(a.type == b.type);
+
+printline("Names are NOT the same");
+printline(a.name != b.name);
+
+printline("1st age less than 2nd");
+printline(a.age < b.age);
+
 if (a.type == b.type && a.name != b.name && a.age < b.age)
  printline("Test passed");
 else
+{
  printline("Test failed");
+  exit(1);
+}

@@ -3,7 +3,8 @@

 typedef enum
 {
-  FZL_BUILTIN_PRINTLINE // Print message in arg with newline at end
+  FZL_BUILTIN_PRINTLINE, // Print message in arg with newline at end
+  FZL_BUILTIN_EXIT,      // Exit program with code specified in arg
 } fzl_builtin_t;

 #endif // FZL_BUILTINS_H
@@ -25,6 +25,7 @@ typedef enum
  FZL_OPCODE_GET_FIELD     = 0xFA0002, // Get field N of an object at dstack
  FZL_OPCODE_SET_FIELD     = 0xFA0003, // Set field N of an object at dstack
  FZL_OPCODE_ESCAPE_OBJECT = 0xFA0004, // Make parent envtable as owner
+  FZL_OPCODE_DEREFERENCE   = 0xFA0005, // Dereference address

  FZL_OPCODE_ADD = 0xA00001, // Sum two numbers in dstack
  FZL_OPCODE_SUB = 0xA00002, // Subract two numbers in dstack
@@ -34,6 +34,7 @@ typedef enum
  FZL_TOKTYPE_STR_LITERAL,  // ""
  FZL_TOKTYPE_NUM_LITERAL,  // 123
  FZL_TOKTYPE_BOOL_LITERAL, // true
+  FZL_TOKTYPE_NULL_LITERAL, // null

  FZL_TOKTYPE_DAMPERSAND, // &&
  FZL_TOKTYPE_DVBAR,      // ||
@@ -4,12 +4,12 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>

 // Constant types
 typedef enum
 {
  FZL_CONSTTYPE_STRING,
-  FZL_CONSTTYPE_NUMBER
 } fzl_consttype_t;

 // Constant descriptor
@@ -34,7 +34,7 @@ typedef struct

 typedef struct
 {
-  size_t pool_index;
+  ssize_t pool_index;
 } fzl_const_hash_slot_t;

 // Constant pool descriptor
@@ -53,13 +53,13 @@ typedef struct
 bool fzl_consts_equal(fzl_const_t a, fzl_const_t b);

 // Get hash of specified constant
-static uint32_t fzl_hash_const(fzl_const_t c);
+uint32_t fzl_hash_const(fzl_const_t c);

 // Allocate constants hash pool
 fzl_const_hash_pool_t *fzl_mkconstpool();

 // Resize the hash table
-static void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool);
+void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool);

 // Push constant. Returns unique index
 size_t fzl_consts_pool_add(fzl_const_hash_pool_t *pool, fzl_const_t c);
@@ -30,9 +30,6 @@ typedef struct
  // Environment stack
  fzl_vm_env_t *estack[256];
  size_t etop;
-
-  fzl_vm_object_t *objects[256];
-  size_t objects_count;
 } fzl_vm_t;

 // Allocate FZL VM
@@ -27,7 +27,6 @@ void print_node(fzl_node_t *node, int level)
  if (!node)
    return;

-  size_t lvllen = print_level(levelbuf, level);
  strcpy(printbuf, levelbuf);

  switch (node->type)
@@ -9,6 +9,24 @@
 char plast_err[256];
 fzl_token_t *last_known_tok = NULL;

+fzl_token_t null_tok = {
+    .type        = FZL_TOKTYPE_TYPE,
+    .filename    = "",
+    .ln          = 0,
+    .cn          = 0,
+    .store_value = false,
+    .value       = "null",
+    .value_sz    = 4,
+};
+
+fzl_token_t this_tok = {.type        = FZL_TOKTYPE_NAME,
+                        .filename    = "",
+                        .ln          = 0,
+                        .cn          = 0,
+                        .store_value = false,
+                        .value       = "this",
+                        .value_sz    = 4};
+
 fzl_parser_t *fzl_mkparser(fzl_reader_ll_t *first)
 {
  if (!first)
@@ -35,6 +53,7 @@ fzl_parser_t *fzl_mkparser(fzl_reader_ll_t *first)
 fzl_node_t *fzl_mknode(fzl_nodetype_t type, fzl_token_t *token)
 {
  fzl_node_t *node = malloc(sizeof(fzl_node_t));
+  memset(node, 0, sizeof(fzl_node_t));

  if (!node)
    return NULL;
@@ -56,19 +75,6 @@ static fzl_token_t *peek(fzl_parser_t *parser)
  return parser->cursor->token;
 }

-// Get token at (cursor + 1)
-static fzl_token_t *next(fzl_parser_t *parser)
-{
-  if (!parser || !parser->cursor)
-    return NULL;
-
-  fzl_reader_ll_t *next = parser->cursor->next;
-  if (!next)
-    return NULL;
-
-  return next->token;
-}
-
 // Consume token at cursor and move to the next
 static fzl_token_t *consume(fzl_parser_t *parser)
 {
@@ -140,17 +146,10 @@ fzl_node_t *parse_primary(fzl_parser_t *parser)
  if (!parser || !peek(parser))
    return NULL;

-  if (is(parser, FZL_TOKTYPE_STR_LITERAL))
-  {
-    fzl_token_t *tok = consume(parser);
-    return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
-  }
-  else if (is(parser, FZL_TOKTYPE_NUM_LITERAL))
-  {
-    fzl_token_t *tok = consume(parser);
-    return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
-  }
-  else if (is(parser, FZL_TOKTYPE_BOOL_LITERAL))
+  if (is(parser, FZL_TOKTYPE_STR_LITERAL) ||
+      is(parser, FZL_TOKTYPE_NUM_LITERAL) ||
+      is(parser, FZL_TOKTYPE_BOOL_LITERAL) ||
+      is(parser, FZL_TOKTYPE_NULL_LITERAL))
  {
    fzl_token_t *tok = consume(parser);
    return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
@@ -211,8 +210,7 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
  if (!parser)
    return NULL;

-  fzl_node_t *left  = parse_primary(parser);
-  fzl_node_t *right = NULL;
+  fzl_node_t *left = parse_primary(parser);

  if (!left)
  {
@@ -247,7 +245,7 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
          if (args_capacity <= args_count)
          {
            args_capacity *= 2;
-            args = realloc(args, args_capacity * sizeof(fzl_node_t));
+            args = realloc(args, args_capacity * sizeof(fzl_node_t *));
          }

          args[args_count] = arg;
@@ -721,19 +719,27 @@ fzl_node_t *parse_class(fzl_parser_t *parser)
        }
      }

-      fzl_node_t **new_args = realloc(node->fn.args, ++node->fn.args_count);
-      memcpy(&new_args[1], new_args,
-             (node->fn.args_count - 1) * sizeof(fzl_node_t *));
+      fzl_node_t **new_args = realloc(node->fn.args, (++node->fn.args_count) *
+                                                         sizeof(fzl_node_t *));
+      if (!new_args)
+      {
+        snprintf(plast_err, sizeof(plast_err),
+                 "failed to reallocate method args list");
+        free(fields);
+        return NULL;
+      }

-      fzl_token_t *this_tok =
-          fzl_mktoken(FZL_TOKTYPE_NAME, node->fn.name->ln, node->fn.name->cn,
-                      "this", 4, node->fn.name->filename);
-      fzl_node_t *this_id      = fzl_mknode(FZL_NODETYPE_IDENTIFIER, this_tok);
+      if (node->fn.args_count > 1)
+        memmove(&new_args[1], new_args,
+                (node->fn.args_count - 1) * sizeof(fzl_node_t *));
+
+      fzl_node_t *this_id      = fzl_mknode(FZL_NODETYPE_IDENTIFIER, &this_tok);
      fzl_node_t *this_dec     = fzl_mknode(FZL_NODETYPE_DECLARATION, name);
      this_dec->var.type       = name;
      this_dec->var.identifier = this_id;

      new_args[0]       = this_dec;
+      node->fn.args     = new_args;
      methods[mcount++] = node;
    }
    else
@@ -773,7 +779,15 @@ fzl_node_t *parse_function(fzl_parser_t *parser)
  if (!parser)
    return NULL;

-  fzl_token_t *fn   = consume(parser);
+  fzl_token_t *fn = consume(parser);
+  if (fn->type != FZL_TOKTYPE_FUNCTION)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': expected keyword 'fn' at %ld:%ld", last_known_tok->filename,
+             last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
  fzl_token_t *name = consume(parser);
  if (!name || name->type != FZL_TOKTYPE_NAME)
  {
@@ -822,13 +836,12 @@ fzl_node_t *parse_function(fzl_parser_t *parser)
    return NULL;
  }

-  fzl_token_t *type;
+  fzl_token_t *type = NULL;
  if (is(parser, FZL_TOKTYPE_TYPE) || is(parser, FZL_TOKTYPE_NAME))
    type = consume(parser);

  if (!type)
-    type = fzl_mktoken(FZL_TOKTYPE_TYPE, last_known_tok->ln, last_known_tok->cn,
-                       "null", 4, last_known_tok->filename);
+    type = &null_tok;

  if (!is(parser, FZL_TOKTYPE_LBRACE))
  {
@@ -966,6 +979,9 @@ fzl_node_t *parse_block(fzl_parser_t *parser)
 // Statement parsing
 fzl_node_t *parse_statement(fzl_parser_t *parser)
 {
+  if (!peek(parser))
+    return NULL;
+
  fzl_node_t *res = NULL;

  if (is(parser, FZL_TOKTYPE_CLASS))
@@ -997,6 +1013,9 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
 // Internal parsing entry point
 fzl_node_t *parse_program(fzl_parser_t *parser)
 {
+  if (!peek(parser))
+    return NULL;
+
  fzl_node_t *first = NULL;
  fzl_node_t *last  = NULL;
  fzl_node_t *node  = NULL;
@@ -1030,6 +1049,8 @@ fzl_node_t *parse_program(fzl_parser_t *parser)
 // Parse tokens and build AST
 int fzl_parse(fzl_parser_t *parser)
 {
+  last_known_tok = NULL;
+
  fzl_node_t *ast = parse_program(parser);
  if (!ast)
    return -1;
@@ -1056,80 +1077,119 @@ void fzl_freeast(fzl_node_t *root)

  while (root)
  {
-    if (root->type == FZL_NODETYPE_BLOCK)
+    switch (root->type)
    {
-      if (root->list.entries)
-      {
-        for (size_t i = 0; i < root->list.entry_count; i++)
-          if (root->list.entries[i])
-            fzl_freeast(root->list.entries[i]);
+      case FZL_NODETYPE_IDENTIFIER:
+      case FZL_NODETYPE_LITERAL:
+        break;

-        free(root->list.entries);
-      }
-    }
-    else if (root->type == FZL_NODETYPE_CALL)
-    {
-      if (root->call.args_count)
-      {
-        for (size_t i = 0; i < root->call.args_count; i++)
-          if (root->call.args[i])
-            fzl_freeast(root->call.args[i]);
+      case FZL_NODETYPE_BLOCK:
+        if (root->list.entries)
+        {
+          for (size_t i = 0; i < root->list.entry_count; i++)
+            if (root->list.entries[i])
+              fzl_freeast(root->list.entries[i]);

-        free(root->call.args);
-      }
-    }
-    else if (root->type == FZL_NODETYPE_ADD || root->type == FZL_NODETYPE_SUB ||
-             root->type == FZL_NODETYPE_MUL || root->type == FZL_NODETYPE_DIV ||
-             root->type == FZL_NODETYPE_POW || root->type == FZL_NODETYPE_MOD)
-    {
-      if (root->binary_op.left)
-        fzl_freeast(root->binary_op.left);
-      if (root->binary_op.right)
-        fzl_freeast(root->binary_op.right);
-    }
-    else if (root->type == FZL_NODETYPE_UNARY_PLUS ||
-             root->type == FZL_NODETYPE_UNARY_MINUS)
-    {
-      if (root->unary_op.operand)
-        fzl_freeast(root->unary_op.operand);
-    }
-    else if (root->type == FZL_NODETYPE_FUNCTION)
-    {
-      if (root->fn.args_count)
-        for (size_t i = 0; i < root->fn.args_count; i++)
-          fzl_freenode(root->fn.args[i]);
-      free(root->fn.args);
-      fzl_freenode(root->fn.body);
-    }
-    else if (root->type == FZL_NODETYPE_RETURN)
-    {
-      if (root->ret.value)
-        fzl_freenode(root->ret.value);
-    }
-    else if (root->type == FZL_NODETYPE_CLASS)
-    {
-      if (root->class.fields_count)
-        for (size_t i = 0; i < root->class.fields_count; i++)
-          fzl_freenode(root->class.fields[i]);
-      free(root->class.fields);
+          free(root->list.entries);
+        }
+        break;

-      if (root->class.methods_count)
-        for (size_t i = 0; i < root->class.methods_count; i++)
-          fzl_freenode(root->class.methods[i]);
-      free(root->class.methods);
-    }
-    else if (root->type == FZL_NODETYPE_CONSTRUCT)
-    {
-      fzl_freenode(root->construct.name);
-    }
-    else if (root->type == FZL_NODETYPE_FIELD)
-    {
-      fzl_freenode(root->memb.field);
-      fzl_freenode(root->memb.parent);
+      case FZL_NODETYPE_CALL:
+        if (root->call.callee)
+          fzl_freeast(root->call.callee);
+
+        if (root->call.args_count)
+        {
+          for (size_t i = 0; i < root->call.args_count; i++)
+            if (root->call.args[i])
+              fzl_freeast(root->call.args[i]);
+        }
+        if (root->call.args)
+          free(root->call.args);
+        break;
+
+      case FZL_NODETYPE_CONDITIONAL:
+        if (root->cond.condition)
+          fzl_freeast(root->cond.condition);
+
+        if (root->cond.true_block)
+          fzl_freeast(root->cond.true_block);
+
+        if (root->cond.else_block)
+          fzl_freeast(root->cond.else_block);
+        break;
+
+      case FZL_NODETYPE_ADD:
+      case FZL_NODETYPE_SUB:
+      case FZL_NODETYPE_MUL:
+      case FZL_NODETYPE_DIV:
+      case FZL_NODETYPE_POW:
+      case FZL_NODETYPE_MOD:
+      case FZL_NODETYPE_OR:
+      case FZL_NODETYPE_AND:
+      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:
+      case FZL_NODETYPE_ASSIGN:
+        if (root->binary_op.left)
+          fzl_freeast(root->binary_op.left);
+        if (root->binary_op.right)
+          fzl_freeast(root->binary_op.right);
+        break;
+
+      case FZL_NODETYPE_UNARY_PLUS:
+      case FZL_NODETYPE_UNARY_MINUS:
+      case FZL_NODETYPE_NOT:
+        if (root->unary_op.operand)
+          fzl_freeast(root->unary_op.operand);
+        break;
+
+      case FZL_NODETYPE_FUNCTION:
+        if (root->fn.args_count)
+          for (size_t i = 0; i < root->fn.args_count; i++)
+            fzl_freeast(root->fn.args[i]);
+        free(root->fn.args);
+        fzl_freeast(root->fn.body);
+        break;
+
+      case FZL_NODETYPE_RETURN:
+        if (root->ret.value)
+          fzl_freeast(root->ret.value);
+        break;
+
+      case FZL_NODETYPE_CLASS:
+        if (root->class.fields_count)
+          for (size_t i = 0; i < root->class.fields_count; i++)
+            fzl_freeast(root->class.fields[i]);
+        free(root->class.fields);
+
+        if (root->class.methods_count)
+          for (size_t i = 0; i < root->class.methods_count; i++)
+            fzl_freeast(root->class.methods[i]);
+        free(root->class.methods);
+        break;
+
+      case FZL_NODETYPE_CONSTRUCT:
+        fzl_freeast(root->construct.name);
+        break;
+
+      case FZL_NODETYPE_FIELD:
+        fzl_freeast(root->memb.field);
+        fzl_freeast(root->memb.parent);
+        break;
+
+      case FZL_NODETYPE_DECLARATION:
+        if (root->var.identifier)
+          fzl_freeast(root->var.identifier);
+        break;
    }

-    root = root->next;
-    free(root);
+    fzl_node_t *next = root->next;
+    fzl_freenode(root);
+    root = next;
  }
 }

@@ -88,13 +88,16 @@ fzl_token_t *parse_name(fzl_reader_t *reader)
  else if (strcmp(value, "true") == 0 || strcmp(value, "false") == 0)
    tok = fzl_mktoken(FZL_TOKTYPE_BOOL_LITERAL, l.line, l.col, value, size,
                      l.filename);
+  else if (strcmp(value, "null") == 0)
+    tok = fzl_mktoken(FZL_TOKTYPE_NULL_LITERAL, l.line, l.col, value, size,
+                      l.filename);
  else if (strcmp(value, "str") == 0 || strcmp(value, "char") == 0 ||
           strcmp(value, "bool") == 0 || strcmp(value, "uint") == 0 ||
           strcmp(value, "int") == 0 || strcmp(value, "i8") == 0 ||
           strcmp(value, "i16") == 0 || strcmp(value, "i32") == 0 ||
           strcmp(value, "i64") == 0 || strcmp(value, "u8") == 0 ||
           strcmp(value, "u16") == 0 || strcmp(value, "u32") == 0 ||
-           strcmp(value, "u64") == 0 || strcmp(value, "null") == 0)
+           strcmp(value, "u64") == 0)
    tok = fzl_mktoken(FZL_TOKTYPE_TYPE, l.line, l.col, value, size, l.filename);
  else
    tok = fzl_mktoken(FZL_TOKTYPE_NAME, l.line, l.col, value, size, l.filename);
@@ -201,31 +204,31 @@ fzl_token_t *parse_number(fzl_reader_t *reader)
 // Add single-char token
 fzl_token_t *add_single(fzl_reader_t *reader, fzl_toktype_t type)
 {
-  size_t p = move(reader, 1);
  fzl_file_loc l;
-  bool ok = fzl_linked_getpos(reader->linked, p, &l);
+  bool ok = fzl_linked_getpos(reader->linked, reader->position, &l);
  if (!ok)
  {
    snprintf(last_err, sizeof(last_err), "failed to locate line:col");
    return NULL;
  }

-  return fzl_mktoken(type, l.line, l.col, NULL, 0, l.filename);
+  move(reader, 1);
+  return fzl_mktoken(type, l.line, l.col, "", 0, l.filename);
 }

 // Add double-char token
 fzl_token_t *add_double(fzl_reader_t *reader, fzl_toktype_t type)
 {
-  size_t p = move(reader, 2);
  fzl_file_loc l;
-  bool ok = fzl_linked_getpos(reader->linked, p, &l);
+  bool ok = fzl_linked_getpos(reader->linked, reader->position, &l);
  if (!ok)
  {
    snprintf(last_err, sizeof(last_err), "failed to locate line:col");
    return NULL;
  }

-  return fzl_mktoken(type, l.line, l.col, NULL, 0, l.filename);
+  move(reader, 2);
+  return fzl_mktoken(type, l.line, l.col, "", 0, l.filename);
 }

 // Skip symbols until '\n' or EOF
@@ -310,7 +313,7 @@ int fzl_read(fzl_reader_t *reader)
      token = add_single(reader, FZL_TOKTYPE_PERCENT);
    else if (curr == '=')
      token = add_single(reader, FZL_TOKTYPE_EQ);
-    else if (curr >= 'A' && curr <= 'Z' || curr >= 'a' && curr <= 'z' ||
+    else if ((curr >= 'A' && curr <= 'Z') || (curr >= 'a' && curr <= 'z') ||
             curr == '_')
      token = parse_name(reader);
    else if (curr >= '0' && curr <= '9')
@@ -350,6 +353,7 @@ int fzl_read(fzl_reader_t *reader)
    }

    fzl_reader_ll_t *tok_node = malloc(sizeof(fzl_reader_ll_t));
+    tok_node->next            = NULL;
    tok_node->token           = token;

    reader->last->next = tok_node;
@@ -6,15 +6,20 @@
 fzl_token_t *fzl_mktoken(const fzl_toktype_t type, size_t line, size_t col,
                         void *value, size_t value_len, char *filename)
 {
-  char *valholder = malloc(value_len + 1);
-  memcpy(valholder, value, value_len);
-  valholder[value_len] = '\0';
+  char *valholder = NULL;
+
+  if (value && value_len > 0)
+  {
+    valholder = malloc(value_len + 1);
+    memcpy(valholder, value, value_len);
+    valholder[value_len] = '\0';
+  }

  fzl_token_t *token = malloc(sizeof(fzl_token_t));
  token->type        = type;
  token->ln          = line;
  token->cn          = col;
-  token->store_value = value_len > 0;
+  token->store_value = (valholder != NULL);
  token->value       = valholder;
  token->value_sz    = value_len;
  token->filename    = filename;
@@ -14,6 +14,7 @@
 #include <stdlib.h>
 #include <string.h>

+char *null_name = "<null>";
 char wlast_err[256];

 fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
@@ -63,7 +64,7 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
 // --- Walking zone ---

 // Convert type token to `fzl_type_t`
-const fzl_type_t tok_to_type(fzl_token_t *tok)
+fzl_type_t tok_to_type(fzl_token_t *tok)
 {
  if (tok->type == FZL_TOKTYPE_NAME)
    return FZL_TYPE_OBJECT;
@@ -105,8 +106,11 @@ static bool is_compatible(fzl_type_t t1, fzl_type_t t2, char *c1, char *c2)
 {
  if (t1 == FZL_TYPE_OBJECT || t2 == FZL_TYPE_OBJECT)
  {
-    return t1 == FZL_TYPE_OBJECT && t2 == FZL_TYPE_OBJECT &&
-           (strcmp(c1, c2) == 0);
+    bool classes_compatible = strcmp(c1, c2) == 0 ||
+                              strcmp(c1, null_name) == 0 ||
+                              strcmp(c2, null_name) == 0;
+
+    return t1 == FZL_TYPE_OBJECT && t2 == FZL_TYPE_OBJECT && classes_compatible;
  }

  if (t1 == t2)
@@ -242,6 +246,9 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
          strcpy((method_name + classname_len + 1), fn->fn.name->value);
          method_name[classname_len + fnname_len + 1] = 0;

+          if (fn->fn.name->value)
+            free(fn->fn.name->value);
+
          fn->fn.name->value   = method_name;
          fzl_walk_res_t fnres = walk(walker, fn);
          if (fnres.error)
@@ -290,44 +297,34 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)

      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;
+        fzl_walk_res_t parent_res = walk(walker, node->memb.parent);
+        if (parent_res.error)
+          return parent_res;

-        if (!exists)
+        if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
        {
-          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);
+          fzl_token_t *tok = node->memb.parent->token;
+          snprintf(
+              wlast_err, sizeof(wlast_err),
+              "'%s': cannot access field '%s' on non-object type at %ld:%ld",
+              tok->filename, (char *)node->memb.field->token->value, tok->ln,
+              tok->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)
+          if (strcmp(parent_res.classname, walker->classes[i]->name) == 0)
          {
            ct = walker->classes[i];
            break;
          }
        }

-        fzl_token_t *tok = node->memb.parent->token;
        if (!ct)
        {
+          fzl_token_t *tok = node->memb.parent->token;
          snprintf(wlast_err, sizeof(wlast_err),
                   "'%s': access to unknown class '%s' at %ld:%ld",
                   tok->filename, (char *)tok->value, tok->ln, tok->cn);
@@ -351,20 +348,17 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        {
          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->filename, (char *)ftok->value, parent_res.classname,
                   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};
+        current_res = (fzl_walk_res_t){.type      = ctf.type,
+                                       .error     = false,
+                                       .classname = parent_res.classname};
        break;
      }

@@ -412,7 +406,7 @@ 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;
+        ssize_t lvl                     = walker->sym_top;
        walker->syms[walker->sym_top++] = fzl_mksymt();

        fzl_walk_ctx_t *newctx = nest_ctx(walker, FZL_WALK_CTX_TYPE_FN);
@@ -483,7 +477,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
          if (retres.error)
            return retres;

-          if (!is_compatible(retres.type, tok_to_type(walker->ctx->fn->fn.type),
+          fzl_node_t *fn_node = walker->ctx->fn;
+          if (!is_compatible(retres.type, tok_to_type(fn_node->fn.type),
                             retres.classname, walker->ctx->fn->fn.type->value))
          {
            snprintf(
@@ -762,6 +757,30 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
          }
          current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
        }
+        else if (strcmp(node->token->value, "exit") == 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_EXIT);
+            if (node->call.args_count < 1)
+            {
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "'%s': 'exit' call with zero arguments at %ld:%ld",
+                       node->token->filename, node->token->ln, node->token->cn);
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+            }
+            current_res =
+                (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
+          }
+        }
        else
        {
          if (node->call.callee->type == FZL_NODETYPE_IDENTIFIER)
@@ -786,8 +805,9 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
            if (!found)
            {
              snprintf(wlast_err, sizeof(wlast_err),
-                       "call to unknown function '%s'",
-                       (char *)node->token->value);
+                       "'%s': call to unknown function '%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};
            }

@@ -807,80 +827,68 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
          else if (node->call.callee->type == FZL_NODETYPE_FIELD)
          {
            fzl_node_t *parent_node = node->call.callee->memb.parent;
+            fzl_node_t *method_node = node->call.callee->memb.field;

-            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;
+            fzl_walk_res_t parent_res = walk(walker, parent_node);
+            if (parent_res.error)
+              return parent_res;

-            if (!found)
+            if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
            {
              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);
+                       "'%s': cannot call method on non-object type at %ld:%ld",
+                       parent_node->token->filename, parent_node->token->ln,
+                       parent_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;
+            char *classname   = parent_res.classname;
+            bool class_exists = false;
            for (size_t i = 0; i < walker->classes_count; i++)
            {
-              if (strcmp(walker->classes[i]->name, res.classname) == 0)
+              if (strcmp(classname, walker->classes[i]->name) == 0)
              {
-                found = true;
+                class_exists = true;
                break;
              }
            }

-            if (!found)
+            if (!class_exists)
            {
              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);
+                       "'%s': class '%s' not found (at %ld:%ld)",
+                       parent_node->token->filename, classname,
+                       parent_node->token->ln, parent_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);
+            size_t classlen  = strlen(classname);
+            size_t fnlen     = strlen(method_node->token->value);
            char *methodname = malloc(classlen + fnlen + 2);
-            strcpy(methodname, res.classname);
+            strcpy(methodname, classname);
            strcpy((methodname + classlen + 1),
                   node->call.callee->token->value);
            methodname[classlen]             = '_';
            methodname[classlen + fnlen + 1] = 0;

-            found = false;
+            fzl_sym_t fn_sym;
+            bool found_method = false;
            for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
-              if ((found = fzl_symt_get(walker->syms[i], methodname, &res)))
+              if ((found_method =
+                       fzl_symt_get(walker->syms[i], methodname, &fn_sym)))
                break;

-            if (!found)
+            if (!found_method)
            {
              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);
+              free(methodname);
              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;
+            free(methodname);

            if (node->call.args_count > 0)
            {
@@ -893,10 +901,11 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
            }

            push_op(walker, FZL_OPCODE_CALL);
-            push_word(walker, res.ip);
+            push_word(walker, fn_sym.ip);

-            current_res = (fzl_walk_res_t){
-                .type = res.type, .error = false, .classname = res.classname};
+            current_res = (fzl_walk_res_t){.type      = fn_sym.type,
+                                           .error     = false,
+                                           .classname = fn_sym.classname};
          }
        }
        break;
@@ -931,6 +940,14 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
          push_word(walker, val);
          current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
        }
+        else if (node->token->type == FZL_TOKTYPE_NULL_LITERAL)
+        {
+          push_op(walker, FZL_OPCODE_PUSHNUM);
+          push_word(walker, 0);
+          push_op(walker, FZL_OPCODE_DEREFERENCE);
+          current_res = (fzl_walk_res_t){
+              .type = FZL_TYPE_OBJECT, .error = false, .classname = null_name};
+        }
        break;

      case FZL_NODETYPE_ADD:
@@ -1130,7 +1147,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
          if (obj_res.error)
            return obj_res;

-          fzl_ctable_t *ct;
+          fzl_ctable_t *ct = NULL;
          for (size_t i = 0; i < walker->classes_count; i++)
          {
            if (strcmp(obj_res.classname, walker->classes[i]->name) == 0)
@@ -1149,7 +1166,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
          }

-          fzl_ctable_field_t *ctf;
+          fzl_ctable_field_t *ctf = NULL;
          for (size_t i = 0; i < ct->fields_count; i++)
          {
            if (strcmp(field_node->memb.field->token->value,
@@ -15,9 +15,15 @@ int main(int argc, char **argv)
 {
  fzl_options_t *opts = fzl_mkoptions(argc, argv);
  if (!opts)
+  {
+    fzl_freeoptions(opts);
    return -1;
+  }
  else if (!opts->should_continue)
+  {
+    fzl_freeoptions(opts);
    return 0;
+  }

  if (opts->verbose)
    printf("%s> analyze\n-> reading file...%s", FZL_CDEBUG, FZL_CRST);
@@ -28,6 +34,8 @@ int main(int argc, char **argv)
    char *lasterr = fzl_linked_geterror();
    if (lasterr[0])
      printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, lasterr);
+    fzl_freeoptions(opts);
+    fzl_freelinked(linked);
    return -1;
  }

@@ -38,6 +46,8 @@ int main(int argc, char **argv)
    char *lasterr = fzl_linked_geterror();
    if (lasterr[0])
      printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, lasterr);
+    fzl_freeoptions(opts);
+    fzl_freelinked(linked);
    return -1;
  }

@@ -53,6 +63,9 @@ int main(int argc, char **argv)
  if (result != 0)
  {
    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_reader_geterror());
+    fzl_freeoptions(opts);
+    fzl_freelinked(linked);
+    fzl_freereader(rd);
    return -1;
  }

@@ -87,6 +100,10 @@ int main(int argc, char **argv)
  if (result != 0)
  {
    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_parser_geterror());
+    fzl_freeoptions(opts);
+    fzl_freeparser(parser);
+    fzl_freereader(rd);
+    fzl_freelinked(linked);
    return -1;
  }

@@ -103,6 +120,11 @@ int main(int argc, char **argv)
  if (result != 0)
  {
    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_walker_geterror());
+    fzl_freeoptions(opts);
+    fzl_freewalker(walker);
+    fzl_freeparser(parser);
+    fzl_freereader(rd);
+    fzl_freelinked(linked);
    return -1;
  }

@@ -144,6 +166,12 @@ int main(int argc, char **argv)
  if (result != 0)
  {
    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_writer_geterror());
+    fzl_freeoptions(opts);
+    fzl_freewriter(writer);
+    fzl_freewalker(walker);
+    fzl_freeparser(parser);
+    fzl_freereader(rd);
+    fzl_freelinked(linked);
    return -1;
  }

@@ -11,31 +11,31 @@ bool fzl_consts_equal(fzl_const_t a, fzl_const_t b)

  switch (a.type)
  {
-  case FZL_CONSTTYPE_STRING:
-  {
-    if (a.as.string.length != b.as.string.length)
-      return false;
+    case FZL_CONSTTYPE_STRING:
+    {
+      if (a.as.string.length != b.as.string.length)
+        return false;

-    return memcmp(a.as.string.chars, b.as.string.chars, a.as.string.length) ==
-           0;
-  }
+      return memcmp(a.as.string.chars, b.as.string.chars, a.as.string.length) ==
+             0;
+    }
  }

  return false;
 }

-static uint32_t fzl_hash_const(fzl_const_t c)
+uint32_t fzl_hash_const(fzl_const_t c)
 {
-  uint32_t hash = 2166136261u;
+  uint32_t hash       = 2166136261u;
  const uint8_t *data = NULL;
-  size_t size = 0;
+  size_t size         = 0;

  switch (c.type)
  {
-  case FZL_CONSTTYPE_STRING:
-    data = (const uint8_t *)c.as.string.chars;
-    size = c.as.string.length;
-    break;
+    case FZL_CONSTTYPE_STRING:
+      data = (const uint8_t *)c.as.string.chars;
+      size = c.as.string.length;
+      break;
  }

  for (size_t i = 0; i < size; i++)
@@ -51,27 +51,27 @@ fzl_const_hash_pool_t *fzl_mkconstpool()
 {
  fzl_const_hash_pool_t *pool = malloc(sizeof(fzl_const_hash_pool_t));

-  pool->size = 0;
+  pool->size     = 0;
  pool->capacity = 8;
-  pool->array = malloc(pool->capacity * sizeof(fzl_const_t));
+  pool->array    = malloc(pool->capacity * sizeof(fzl_const_t));

-  pool->slots_count = 0;
+  pool->slots_count    = 0;
  pool->slots_capacity = 16;
  pool->slots = malloc(pool->slots_capacity * sizeof(fzl_const_hash_slot_t));
-  for (int i = 0; i < pool->slots_capacity; i++)
+  for (size_t i = 0; i < pool->slots_capacity; i++)
    pool->slots[i].pool_index = -1;

  return pool;
 }

-static void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool)
+void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool)
 {
-  int old_capacity = pool->slots_capacity;
+  int old_capacity                 = pool->slots_capacity;
  fzl_const_hash_slot_t *old_slots = pool->slots;

  pool->slots_capacity = old_capacity * 2;
  pool->slots = malloc(pool->slots_capacity * sizeof(fzl_const_hash_slot_t));
-  for (int i = 0; i < pool->slots_capacity; i++)
+  for (size_t i = 0; i < pool->slots_capacity; i++)
    pool->slots[i].pool_index = -1;
  pool->slots_count = 0;

@@ -81,8 +81,8 @@ static void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool)
      continue;

    int index_in_pool = old_slots[i].pool_index;
-    fzl_const_t c = pool->array[index_in_pool];
-    uint32_t hash = fzl_hash_const(c);
+    fzl_const_t c     = pool->array[index_in_pool];
+    uint32_t hash     = fzl_hash_const(c);

    uint32_t bucket = hash & (pool->slots_capacity - 1);
    while (pool->slots[bucket].pool_index != -1)
@@ -100,7 +100,7 @@ size_t fzl_consts_pool_add(fzl_const_hash_pool_t *pool, fzl_const_t c)
  if (pool->slots_count * 4 >= pool->slots_capacity * 3)
    fzl_consts_pool_resize_hash(pool);

-  uint32_t hash = fzl_hash_const(c);
+  uint32_t hash   = fzl_hash_const(c);
  uint32_t bucket = hash & (pool->slots_capacity - 1);

  while (pool->slots[bucket].pool_index != -1)
@@ -119,7 +119,7 @@ size_t fzl_consts_pool_add(fzl_const_hash_pool_t *pool, fzl_const_t c)
                                         pool->capacity * sizeof(fzl_const_t));
  }

-  size_t new_index = pool->size;
+  size_t new_index       = pool->size;
  pool->array[new_index] = c;
  pool->size++;

@@ -72,9 +72,9 @@ bool fzl_linked_add_files(fzl_linked_t *l, char **files, size_t files_count)
                             .end   = current_start + file_sz - 1};

    if (!l->source)
-      l->source = malloc(file_sz);
+      l->source = malloc(file_sz + 1);
    else
-      l->source = realloc(l->source, current_start + file_sz);
+      l->source = realloc(l->source, current_start + file_sz + 1);

    if (!l->source)
    {
@@ -86,6 +86,7 @@ bool fzl_linked_add_files(fzl_linked_t *l, char **files, size_t files_count)
    }

    strcpy(l->source + current_start, source);
+    free(source);
    current_start += file_sz;
  }

@@ -35,7 +35,7 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
    return opts;
  }

-  size_t i;
+  int i;
  for (i = 1; i < argc; i++)
  {
    if (argv[i][0] != '-')
@@ -108,7 +108,7 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
  {
    printf("%sError%s: flags should go before source files list.\n", FZL_CERROR,
           FZL_CRST);
-    printf("Remain %zu arguments are not handled.\n", argc - 1 - i);
+    printf("Remain %d arguments are not handled.\n", argc - 1 - i);

    free(files);
    free(opts);
@@ -25,25 +25,24 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
    return NULL;
  }

-  vm->consts        = NULL;
-  vm->consts_count  = 0;
-  vm->ops           = NULL;
-  vm->ops_count     = 0;
-  vm->ip            = 0;
-  vm->dtop          = 0;
-  vm->ctop          = 0;
-  vm->etop          = 0;
-  vm->objects_count = 0;
+  vm->consts       = NULL;
+  vm->consts_count = 0;
+  vm->ops          = NULL;
+  vm->ops_count    = 0;
+  vm->ip           = 0;
+  vm->dtop         = 0;
+  vm->ctop         = 0;
+  vm->etop         = 0;

  memset(vm->dstack, 0, sizeof(vm->dstack));
  memset(vm->cstack, 0, sizeof(vm->cstack));
  memset(vm->estack, 0, sizeof(vm->estack));
-  memset(vm->objects, 0, sizeof(vm->objects));

  FILE *fd = fopen(filepath, "rb");
  if (!fd)
  {
    snprintf(last_err, sizeof(last_err), "failed to open file '%s'", filepath);
+    free(vm);
    return NULL;
  }

@@ -52,6 +51,8 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
  if (memcmp(hdr, expect_hdr, 5) != 0)
  {
    snprintf(last_err, sizeof(last_err), "magic check error");
+    fclose(fd);
+    free(vm);
    return NULL;
  }

@@ -62,6 +63,8 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
  if (ops_count < 1)
  {
    snprintf(last_err, sizeof(last_err), "there is nothing to do (0 ops)");
+    fclose(fd);
+    free(vm);
    return NULL;
  }

@@ -91,6 +94,9 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
      }
      else
      {
+        fclose(fd);
+        free(vm->consts);
+        free(vm);
        snprintf(last_err, sizeof(last_err), "unknown const type at index %ld",
                 i);
        return NULL;
@@ -106,10 +112,62 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
    fread(&op, sizeof(uint64_t), 1, fd);
    vm->ops[i] = op;
  }
+  fclose(fd);

  return vm;
 }

+// Escape objects with nested objects check
+static void escape_recursive(fzl_vm_env_t *current, fzl_vm_env_t *parent,
+                             fzl_vm_object_t *obj)
+{
+  if (!current || !parent || !obj)
+    return;
+
+  bool found_in_current = false;
+  for (size_t i = 0; i < current->owned_objects_count; i++)
+  {
+    if (current->owned_objects[i] == obj)
+    {
+      current->owned_objects[i] = NULL;
+      found_in_current          = true;
+      break;
+    }
+  }
+
+  if (found_in_current)
+  {
+    bool found_in_parent = false;
+    for (size_t i = 0; i < parent->owned_objects_count; i++)
+    {
+      if (parent->owned_objects[i] == obj)
+      {
+        found_in_parent = true;
+        break;
+      }
+    }
+
+    if (!found_in_parent)
+    {
+      if (parent->owned_objects_remainder <= parent->owned_objects_count)
+      {
+        parent->owned_objects_remainder *= 2;
+        parent->owned_objects =
+            realloc(parent->owned_objects, parent->owned_objects_remainder *
+                                               sizeof(fzl_vm_object_t *));
+      }
+
+      parent->owned_objects[parent->owned_objects_count++] = obj;
+    }
+  }
+
+  for (size_t i = 0; i < obj->values_count; i++)
+  {
+    if (obj->values[i].type == FZL_TYPE_OBJECT && obj->values[i].as.obj != NULL)
+      escape_recursive(current, parent, obj->values[i].as.obj);
+  }
+}
+
 void print_object(fzl_vm_object_t *obj)
 {
  if (!obj)
@@ -135,7 +193,7 @@ void print_object(fzl_vm_object_t *obj)
    else if (arg.type == FZL_TYPE_UINT)
      printf("uint(%lu)", arg.as.u);
    else if (arg.type == FZL_TYPE_BOOL)
-      printf("bool(%b)", arg.as.b);
+      printf("bool(%s)", arg.as.b ? "true" : "false");
    else if (arg.type == FZL_TYPE_NULL)
      printf("<null>");
    else if (arg.type == FZL_TYPE_OBJECT)
@@ -147,6 +205,74 @@ void print_object(fzl_vm_object_t *obj)
  printf(">\n");
 }

+void print_err_data(fzl_vm_t *vm)
+{
+  printf("===== ERROR =====\n");
+  printf("> Caused on IP: %zu\n", vm->ip);
+
+  printf("\n> Data stack:\n");
+  if (vm->dtop > 0)
+  {
+    for (ssize_t i = vm->dtop - 1; i >= 0; i--)
+    {
+      printf("\t> [%d] ", vm->dstack[i].type);
+      switch (vm->dstack[i].type)
+      {
+        case FZL_TYPE_OBJECT:
+          printf("ref: %p\n", vm->dstack[i].as.obj);
+          break;
+        case FZL_TYPE_STRING:
+          printf("str: '%s'\n", vm->dstack[i].as.s.value);
+          break;
+        case FZL_TYPE_NULL:
+          printf("<null>\n");
+          break;
+        default:
+          printf("%lu\n", vm->dstack[i].as.u);
+          break;
+      }
+    }
+  }
+  else
+  {
+    printf("\tEmpty\n");
+  }
+
+  printf("\n> Environments:\n");
+  for (ssize_t i = vm->etop - 1; i >= 0; i--)
+  {
+    fzl_vm_env_t *env = vm->estack[i];
+    printf("\t> [%zd] %p:\n", i, env);
+
+    printf("\t\t> Owned objects (%zu/%zu):\n", env->owned_objects_count,
+           env->owned_objects_remainder);
+    for (size_t j = 0; j < env->owned_objects_count; j++)
+      printf("\t\t\t> ref: %p (entries: %zu)\n", env->owned_objects[j],
+             env->owned_objects[j]->values_count);
+
+    printf("\t\t> Local entries (%zu/%zu):\n", env->size, env->remainder);
+    for (size_t j = 0; j < env->size; j++)
+    {
+      switch (env->table[j].value.type)
+      {
+        case FZL_TYPE_OBJECT:
+          printf("\t\t\t> [%d] %s = ref %p\n", env->table[j].value.type,
+                 env->table[j].name, env->table[j].value.as.obj);
+          break;
+
+        default:
+          printf("\t\t\t> [%d] %s = %lu\n", env->table[j].value.type,
+                 env->table[j].name, env->table[j].value.as.u);
+          break;
+      }
+    }
+  }
+
+  printf("\n> Call stack:\n");
+  for (ssize_t i = vm->ctop - 1; i >= 0; i--)
+    printf("\t> [%zd] %lu\n", i, vm->cstack[i]);
+}
+
 int fzl_vm_run(fzl_vm_t *vm)
 {
  if (!vm)
@@ -162,12 +288,44 @@ int fzl_vm_run(fzl_vm_t *vm)

    switch (opcode)
    {
+      case FZL_OPCODE_DEREFERENCE:
+      {
+        if (vm->dtop < 1)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - expected value in data stack");
+          print_err_data(vm);
+          return -1;
+        }
+
+        fzl_value_t addr = vm->dstack[--vm->dtop];
+        if (addr.type < FZL_TYPE_INT8)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - expected address");
+          print_err_data(vm);
+          return -1;
+        }
+
+        if (addr.as.u == 0)
+        {
+          vm->dstack[vm->dtop++] =
+              (fzl_value_t){.type = FZL_TYPE_OBJECT, .as.obj = NULL};
+          break;
+        }
+
+        vm->dstack[vm->dtop++] = (fzl_value_t){
+            .type = FZL_TYPE_OBJECT, .as.obj = (fzl_vm_object_t *)addr.as.u};
+        break;
+      }
+
      case FZL_OPCODE_CMP_EQ_STR:
      {
        if (vm->dtop < 2)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t left  = vm->dstack[--vm->dtop];
@@ -185,6 +343,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t left  = vm->dstack[--vm->dtop];
@@ -202,13 +361,14 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t left  = vm->dstack[--vm->dtop];
        fzl_value_t right = vm->dstack[--vm->dtop];

        vm->dstack[vm->dtop++] = (fzl_value_t){
-            .type = FZL_TYPE_BOOL, .as.b = &left.as.obj == &right.as.obj};
+            .type = FZL_TYPE_BOOL, .as.b = left.as.obj == right.as.obj};
        break;
      }

@@ -218,13 +378,14 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t left  = vm->dstack[--vm->dtop];
        fzl_value_t right = vm->dstack[--vm->dtop];

        vm->dstack[vm->dtop++] = (fzl_value_t){
-            .type = FZL_TYPE_BOOL, .as.b = &left.as.obj != &right.as.obj};
+            .type = FZL_TYPE_BOOL, .as.b = left.as.obj != right.as.obj};
        break;
      }

@@ -234,6 +395,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - missing value in data stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t obj = vm->dstack[--vm->dtop];
@@ -241,41 +403,21 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - cannot escape non-object type");
+          print_err_data(vm);
          return -1;
        }

        fzl_vm_env_t *parent  = vm->estack[vm->etop - 2];
        fzl_vm_env_t *current = vm->estack[vm->etop - 1];
-        if (!parent || vm->etop < 2)
+        if (vm->etop < 2)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - cannot escape object from global env");
+          print_err_data(vm);
          return -1;
        }

-        bool found = false;
-        for (size_t i = 0; i < current->owned_objects_count; i++)
-        {
-          if (obj.as.obj == current->owned_objects[i])
-          {
-            found                     = true;
-            current->owned_objects[i] = NULL;
-            break;
-          }
-        }
-
-        if (found)
-        {
-          if (parent->owned_objects_remainder <= parent->owned_objects_count)
-          {
-            parent->owned_objects_remainder *= 2;
-            parent->owned_objects =
-                realloc(parent->owned_objects, parent->owned_objects_remainder *
-                                                   sizeof(fzl_vm_object_t *));
-          }
-
-          parent->owned_objects[parent->owned_objects_count++] = obj.as.obj;
-        }
+        escape_recursive(current, parent, obj.as.obj);
        vm->dstack[vm->dtop++] = obj;

        break;
@@ -310,6 +452,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected value in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -321,6 +464,7 @@ int fzl_vm_run(fzl_vm_t *vm)
              last_err, sizeof(last_err),
              "runtime error - cannot access field #%lu of non-object type",
              field_slot);
+          print_err_data(vm);
          return -1;
        }

@@ -329,6 +473,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - cannot access field #%lu", field_slot);
+          print_err_data(vm);
          return -1;
        }

@@ -342,6 +487,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -354,6 +500,7 @@ int fzl_vm_run(fzl_vm_t *vm)
              last_err, sizeof(last_err),
              "runtime error - cannot access field #%lu of non-object type",
              field_slot);
+          print_err_data(vm);
          return -1;
        }

@@ -362,6 +509,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - cannot access field #%lu", field_slot);
+          print_err_data(vm);
          return -1;
        }

@@ -383,6 +531,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - no place to jump");
+          print_err_data(vm);
          return -1;
        }

@@ -395,6 +544,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -409,6 +559,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -423,11 +574,12 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

-        fzl_value_t llt = vm->dstack[--vm->dtop];
        fzl_value_t rlt = vm->dstack[--vm->dtop];
+        fzl_value_t llt = vm->dstack[--vm->dtop];
        vm->dstack[vm->dtop++] =
            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = llt.as.u < rlt.as.u};
        break;
@@ -437,6 +589,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -451,6 +604,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -465,6 +619,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -479,6 +634,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected value in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -492,6 +648,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected value in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -502,14 +659,24 @@ int fzl_vm_run(fzl_vm_t *vm)
        break;

      case FZL_OPCODE_JMP:
-        vm->ip = vm->ops[++vm->ip] - 1;
+      {
+        if (vm->ops_count <= vm->ip)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - expected JMP addr");
+          return -1;
+        }
+        uint64_t jmp_ip = vm->ops[++vm->ip];
+        vm->ip          = jmp_ip - 1;
        break;
+      }

      case FZL_OPCODE_AND:
        if (vm->dtop < 2)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -524,6 +691,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -538,6 +706,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected var name in data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -552,14 +721,36 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected 2 values in data stack");
+          print_err_data(vm);
          return -1;
        }

        fzl_value_t writevar = vm->dstack[--vm->dtop];
        fzl_value_t value    = vm->dstack[--vm->dtop];

-        fzl_vm_env_wresult_t wresult = fzl_env_writevalue(
-            vm->estack[vm->etop - 1], (char *)writevar.as.s.value, value);
+        char *wrname = (char *)writevar.as.s.value;
+        bool wrfound;
+        fzl_value_t wrenv;
+        ssize_t wrlvl = -1;
+        for (ssize_t i = vm->etop - 1; i >= 0; i--)
+        {
+          if ((wrfound = fzl_env_lookup(vm->estack[i], wrname, &wrenv)))
+          {
+            wrlvl = i;
+            break;
+          }
+        }
+
+        if (wrlvl <= -1)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - name '%s' not found in this scope", wrname);
+          print_err_data(vm);
+          return -1;
+        }
+
+        fzl_vm_env_wresult_t wresult =
+            fzl_env_writevalue(vm->estack[wrlvl], (char *)wrname, value);
        if (wresult != FZL_VM_ENV_WRESULT_OK)
        {
          switch (wresult)
@@ -567,21 +758,25 @@ int fzl_vm_run(fzl_vm_t *vm)
            case FZL_VM_ENV_WRESULT_ERR:
              snprintf(last_err, sizeof(last_err),
                       "runtime error - failed to write variable");
+              print_err_data(vm);
              return -1;

            case FZL_VM_ENV_WRESULT_ERR_EXISTS:
              snprintf(last_err, sizeof(last_err),
                       "runtime error - redefenition of '%s'",
                       writevar.as.s.value);
+              print_err_data(vm);
              return -1;

            case FZL_VM_ENV_WRESULT_ERR_NOT_FOUND:
              snprintf(last_err, sizeof(last_err),
                       "runtime error - cannot find name '%s'",
                       writevar.as.s.value);
+              print_err_data(vm);
              return -1;

            default:
+              print_err_data(vm);
              return -1;
          }
        }
@@ -605,6 +800,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - LOOKUP_ENV: empty data stack");
+          print_err_data(vm);
          return -1;
        }

@@ -637,16 +833,22 @@ int fzl_vm_run(fzl_vm_t *vm)
          else if (arg.type == FZL_TYPE_UINT)
            printf("%lu\n", arg.as.u);
          else if (arg.type == FZL_TYPE_BOOL)
-            printf("%b\n", arg.as.b);
+            printf("%s\n", arg.as.b ? "true" : "false");
          else if (arg.type == FZL_TYPE_NULL)
            printf("<null>\n");
          else if (arg.type == FZL_TYPE_OBJECT)
            print_object(arg.as.obj);
        }
+        else if (fn_id == FZL_BUILTIN_EXIT)
+        {
+          fzl_value_t arg = vm->dstack[--vm->dtop];
+          return arg.as.i;
+        }
        else
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - undefined builtin %lu", fn_id);
+          print_err_data(vm);
          return -1;
        }
      }
@@ -658,6 +860,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        if (vm->consts_count <= cn)
        {
          snprintf(last_err, sizeof(last_err), "runtime error - unknown const");
+          print_err_data(vm);
          return -1;
        }
        fzl_const_t c = vm->consts[cn];
@@ -673,6 +876,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected 2 values in stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t add1 = vm->dstack[--vm->dtop];
@@ -686,6 +890,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected 2 values in stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t sub2 = vm->dstack[--vm->dtop];
@@ -699,6 +904,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected 2 values in stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t mul1 = vm->dstack[--vm->dtop];
@@ -712,6 +918,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected 2 values in stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t div1 = vm->dstack[--vm->dtop];
@@ -725,6 +932,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected 2 values in stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t pow2 = vm->dstack[--vm->dtop];
@@ -745,6 +953,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected 2 values in stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t mod1 = vm->dstack[--vm->dtop];
@@ -758,6 +967,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected value in stack");
+          print_err_data(vm);
          return -1;
        }
        fzl_value_t neg_n = vm->dstack[--vm->dtop];
@@ -784,6 +994,7 @@ int fzl_vm_run(fzl_vm_t *vm)
      default:
        snprintf(last_err, sizeof(last_err),
                 "runtime error - unknown opcode %u", opcode);
+        print_err_data(vm);
        return -1;
    }

@@ -800,18 +1011,15 @@ void fzl_freevm(fzl_vm_t *vm)
  if (!vm)
    return;

+  while (vm->etop > 0)
+    fzl_freeenv(vm->estack[--vm->etop]);
+
  for (size_t i = 0; i < vm->consts_count; i++)
  {
    if (vm->consts[i].type == FZL_CONSTTYPE_STRING)
      free((void *)vm->consts[i].as.string.chars);
  }

-  for (size_t i = 0; i < vm->objects_count; i++)
-  {
-    free(vm->objects[i]->values);
-    free(vm->objects[i]);
-  }
-
  free(vm->consts);
  free(vm->ops);
  free(vm);
@@ -20,6 +20,10 @@ void fzl_vm_print_ops(fzl_vm_t *vm)

    switch (vm->ops[i])
    {
+      case FZL_OPCODE_DEREFERENCE:
+        printf("DEREFERENCE\n");
+        break;
+
      case FZL_OPCODE_CMP_EQ_STR:
        printf("CMP_EQ_STR\n");
        break;
@@ -7,8 +7,6 @@
 #include <string.h>
 #include <vm/fzl_vm_env.h>

-static const fzl_value_t null = {.type = FZL_TYPE_NULL};
-
 fzl_vm_env_t *fzl_mkenv()
 {
  fzl_vm_env_t *env = malloc(sizeof(fzl_vm_env_t));
@@ -109,7 +107,9 @@ void fzl_freeenv(fzl_vm_env_t *env)
      if (!env->owned_objects[i])
        continue;

-      free(env->owned_objects[i]->values);
+      if (env->owned_objects[i]->values)
+        free(env->owned_objects[i]->values);
+
      free(env->owned_objects[i]);
    }

@@ -33,7 +33,7 @@ run_args_t *parse_args(int argc, char **argv)
  args->help       = false;
  args->debug      = false;

-  for (size_t i = 0; i < argc; i++)
+  for (int i = 0; i < argc; i++)
  {
    if (argv[i][0] != '-')
      continue;
@@ -49,6 +49,7 @@ run_args_t *parse_args(int argc, char **argv)
    {
      printf("Error: unknown flag '%s'.\n", argv[i]);
      printf("Use 'fz --help' to read the usage\n");
+      free(args);
      return NULL;
    }
  }
@@ -57,6 +58,7 @@ run_args_t *parse_args(int argc, char **argv)
  {
    printf("Error: last argument MUST be a file path\n");
    printf("Use 'fz --help' for help\n");
+    free(args);
    return NULL;
  }

@@ -73,6 +75,7 @@ int main(int argc, char **argv)
  else if (args->help)
  {
    print_hint();
+    free(args);
    return 0;
  }

@@ -80,6 +83,7 @@ int main(int argc, char **argv)
  if (!vm)
  {
    printf("Error: %s\n", fzl_vm_geterror());
+    free(args);
    return -1;
  }

@@ -90,7 +94,12 @@ int main(int argc, char **argv)
    int result = fzl_vm_run(vm);
    if (result != 0)
    {
-      printf("Error: %s\n", fzl_vm_geterror());
+      char *err = fzl_vm_geterror();
+      if (err && err[0])
+        printf("Error: %s\n", err);
+
+      free(args);
+      fzl_freevm(vm);
      return -1;
    }
  }
Author	SHA1	Message	Date
samsonium	1e518c4c82	fix: sanitizer checks fix (iteration 3 - final)	2026-10-19 20:11:48 +03:00
samsonium	3f2f03f931	fix: sanitizer checks fix (iteration 2)	2026-10-19 19:54:11 +03:00
samsonium	1289f6c150	fix: sanitizer checks fix (iteration 1)	2026-10-19 19:41:39 +03:00
samsonium	04b367e7a0	fix: warnings fix (after -Wall -Wextra)	2026-10-19 18:39:40 +03:00
samsonium	d09468cc6b	fix: critical fixes for newer compiler versions - Add token check before parsing statement or program - Fix program freeing	2026-10-19 17:50:31 +03:00
samsonium	41e8600ce4	Merge pull request 'RAII' (#2 ) from impl-dealloc into master Reviewed-on: #2	2026-10-18 18:00:03 +00:00
samsonium	801b28e27d	feat: implement address deferencing	2026-10-18 18:42:02 +03:00
samsonium	c0df5fc9d4	feat: add `exit` builtin function	2026-10-18 18:41:49 +03:00
samsonium	f0e641928d	upd: add `exit` on error in examples	2026-10-18 18:40:48 +03:00
samsonium	dce64e8b4d	fix+ref: small objects rework - Add nested objects escape on ESCAPE opcode - Stabilize objects work in heap	2026-10-18 17:38:49 +03:00
samsonium	0c8c206677	upd: update tests	2026-10-18 17:37:18 +03:00
samsonium	d33aa57f8e	feat: add first hard example Hard example tests all actual language features. For now its: - Classes - Methods - Recursive calls - Object move and borrowing	2026-10-17 21:57:04 +03:00
samsonium	82b6cc3346	feat: add support for null-values	2026-10-17 21:56:08 +03:00
samsonium	244dd33372	feat: new debug print on exception!	2026-10-17 21:55:52 +03:00
samsonium	c0c90f4f1a	fix: clear fn return type value	2026-10-17 21:24:21 +03:00
samsonium	8c33464656	feat: add `null` as value token	2026-10-17 21:23:50 +03:00