Merge pull request 'RAII' (#2) from impl-dealloc into master

Reviewed-on: #2

.gdbinit

@@ -2,17 +2,14 @@ skip peek
 skip consume
 skip next
 skip is
-skip fzl_mknode
+skip -rfunction fzl_mk*
-skip fzl_mktoken
+skip -rfunction fzl_free*
-skip fzl_symt_put
+skip -rfunction fzl_symt*
-skip fzl_symt_get
 skip add_const
 skip push_op
 skip push_word
-skip fzl_mkenv
+skip -rfunction fzl_env*
-skip fzl_freeenv
+skip tok_to_type
-skip fzl_env_lookup
+skip nest_ctx
-skip fzl_env_contains
+skip fin_ctx
-skip fzl_env_storevalue
-skip fzl_env_writevalue
 

CMakeLists.txt

@@ -70,6 +70,18 @@ add_test(
 	NAME compile_class
 	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/class.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/class.fzs"
 )
+add_test(
+	NAME compile_raii
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/raii.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/raii.fzs"
+)
+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)
 
@@ -109,4 +121,16 @@ add_test(
 	NAME runtime_class
 	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/class.fzb"
 )
+add_test(
+	NAME runtime_raii
+	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/raii.fzb"
+)
+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"
+)
 

exl/borrow.fzs

@@ -0,0 +1,46 @@
+class A
+{
+  uint some;
+}
+
+fn doSome(A a) A
+{
+  // NOTE: section below won't change `a.some` value
+
+  if (a.some < 1)
+  {
+    a.some = 1;
+    return a;
+  }
+
+  return a;
+}
+
+fn doSomeNew() A
+{
+  if (1 == 1)
+  {
+    return new A;
+  }
+}
+
+A a = new A;
+a.some = 0;
+if (a.some != 0)
+{
+  printline("Test failed (first a.some != 0)");
+  exit(1);
+}
+else printline(a);
+
+a = doSome(a);
+if (a.some != 1)
+{
+  printline("Test failed (2nd a.some != 1)");
+  exit(1);
+}
+else printline(a);
+
+A b = doSomeNew();
+printline(b);
+

exl/class.fzs

@@ -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);
+}
 

exl/conditions.fzs

@@ -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);
 }
 
 {

exl/fn.fzs

@@ -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);
+}
 

exl/hard-1.fzs

@@ -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);
+}
+

exl/raii.fzs

@@ -0,0 +1,46 @@
+class Animal
+{
+  str type;
+  str name;
+  int age;
+
+  fn copy() Animal
+  {
+    Animal cp = new Animal;
+    cp.type = this.type;
+    cp.name = this.name;
+    cp.age = this.age;
+
+    return cp;
+  }
+}
+
+Animal a = new Animal;
+a.type = "Cow";
+a.name = "Buryatka";
+a.age = 5;
+
+Animal b = a.copy();
+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);
+}
+

include/common/fzl_builtins.h

@@ -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

include/common/fzl_opcodes.h

@@ -24,6 +24,8 @@ typedef enum
   FZL_OPCODE_ALLOC_OBJECT  = 0xFA0001, // Allocate N slots
   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
@@ -40,6 +42,12 @@ typedef enum
   FZL_OPCODE_CMP_GT   = 0xB00005, // Greater than
   FZL_OPCODE_CMP_GTEQ = 0xB00006, // Greater than or equal
 
+  FZL_OPCODE_CMP_EQ_STR  = 0xB10001, // Strings equality
+  FZL_OPCODE_CMP_NEQ_STR = 0xB10002, // Strings non-equality
+
+  FZL_OPCODE_CMP_EQ_OBJ  = 0xB20001, // Objects equality (by pointer)
+  FZL_OPCODE_CMP_NEQ_OBJ = 0xB20002, // Objects non-equality (by pointer)
+
   FZL_OPCODE_AND = 0xC00001, // A && B
   FZL_OPCODE_OR  = 0xC00002, // A || B
 

include/compiler/fzl_token.h

@@ -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,      // ||

include/vm/fzl_vm.h

@@ -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

include/vm/fzl_vm_env.h

@@ -4,6 +4,7 @@
 #include <common/fzl_value.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <vm/fzl_vm_object.h>
 
 typedef enum
 {
@@ -27,6 +28,10 @@ typedef struct
   size_t remainder;
 
   fzl_vm_env_entry_t *table;
+
+  fzl_vm_object_t **owned_objects;
+  size_t owned_objects_remainder;
+  size_t owned_objects_count;
 } fzl_vm_env_t;
 
 // Allocate env table

src/compiler/fzl_parser.c

@@ -140,17 +140,10 @@ fzl_node_t *parse_primary(fzl_parser_t *parser)
   if (!parser || !peek(parser))
     return NULL;
 
-  if (is(parser, FZL_TOKTYPE_STR_LITERAL))
+  if (is(parser, FZL_TOKTYPE_STR_LITERAL) ||
-  {
+      is(parser, FZL_TOKTYPE_NUM_LITERAL) ||
-    fzl_token_t *tok = consume(parser);
+      is(parser, FZL_TOKTYPE_BOOL_LITERAL) ||
-    return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
+      is(parser, FZL_TOKTYPE_NULL_LITERAL))
-  }
-  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))
   {
     fzl_token_t *tok = consume(parser);
     return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
@@ -822,7 +815,7 @@ 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);
 

src/compiler/fzl_reader.c

@@ -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);

src/compiler/fzl_walker.c

@@ -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)
@@ -65,6 +66,9 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
 // Convert type token to `fzl_type_t`
 const fzl_type_t tok_to_type(fzl_token_t *tok)
 {
+  if (tok->type == FZL_TOKTYPE_NAME)
+    return FZL_TYPE_OBJECT;
+
   if (strcmp((char *)tok->value, "i8") == 0)
     return FZL_TYPE_INT8;
   if (strcmp((char *)tok->value, "i16") == 0)
@@ -98,8 +102,17 @@ const fzl_type_t tok_to_type(fzl_token_t *tok)
   return FZL_TYPE_NULL;
 }
 
-static bool is_compatible(fzl_type_t t1, fzl_type_t t2)
+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)
+  {
+    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)
     return true;
 
@@ -281,44 +294,34 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
 
       case FZL_NODETYPE_FIELD:
       {
-        fzl_sym_t sym;
+        fzl_walk_res_t parent_res = walk(walker, node->memb.parent);
-        bool exists = false;
+        if (parent_res.error)
-        for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
+          return parent_res;
-          if ((exists = fzl_symt_get(walker->syms[i],
-                                     node->memb.parent->token->value, &sym)))
-            break;
 
-        if (!exists)
+        if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
         {
-          snprintf(wlast_err, sizeof(wlast_err),
+          fzl_token_t *tok = node->memb.parent->token;
-                   "'%s': cannot find symbol '%s' at %ld:%ld",
+          snprintf(
-                   node->token->filename, (char *)node->token->value,
+              wlast_err, sizeof(wlast_err),
-                   node->token->ln, node->token->cn);
+              "'%s': cannot access field '%s' on non-object type at %ld:%ld",
-          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+              tok->filename, (char *)node->memb.field->token->value, tok->ln,
-        }
+              tok->cn);
-
-        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)
+          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);
@@ -342,20 +345,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){
+        current_res = (fzl_walk_res_t){.type      = ctf.type,
-            .type = ctf.type, .error = false, .classname = sym.classname};
+                                       .error     = false,
+                                       .classname = parent_res.classname};
         break;
       }
 
@@ -369,6 +369,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         fzl_symtable_res_t putres =
             fzl_symt_put(walker->syms[walker->sym_top - 1],
                          node->fn.name->value, fntype, walker->op_count);
+
         if (putres != FZL_SYMTABLE_RESULT_OK)
         {
           if (putres == FZL_SYMTABLE_RESULT_EXISTS)
@@ -382,7 +383,23 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
                      "'%s': failed to store name '%s'", node->fn.name->filename,
                      (char *)node->fn.name->value);
 
-          return (fzl_walk_res_t){.error = true};
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        if (fntype == FZL_TYPE_OBJECT)
+        {
+          fzl_symtable_res_t updres =
+              fzl_symt_setobjclass(walker->syms[walker->sym_top - 1],
+                                   node->fn.name->value, node->fn.type->value);
+          if (updres != FZL_SYMTABLE_RESULT_OK)
+          {
+            snprintf(wlast_err, sizeof(wlast_err),
+                     "'%s': failed to assign object type to function return "
+                     "type at %ld:%ld",
+                     node->fn.type->filename, node->fn.type->ln,
+                     node->fn.type->cn);
+            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+          }
         }
 
         // NOTE: add sym_top limit check
@@ -430,7 +447,12 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         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};
+        char *retclass = NULL;
+        if (fntype == FZL_TYPE_OBJECT && node->fn.type)
+          retclass = node->fn.type->value;
+
+        current_res = (fzl_walk_res_t){
+            .type = fntype, .error = false, .classname = retclass};
         break;
       }
 
@@ -445,14 +467,16 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
           return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
         }
 
+        bool returning_object = false;
         if (node->ret.value)
         {
           fzl_walk_res_t retres = walk(walker, node->ret.value);
           if (retres.error)
             return retres;
 
-          if (!is_compatible(retres.type,
+          fzl_node_t *fn_node = walker->ctx->fn;
-                             tok_to_type(walker->ctx->fn->fn.type)))
+          if (!is_compatible(retres.type, tok_to_type(fn_node->fn.type),
+                             retres.classname, walker->ctx->fn->fn.type->value))
           {
             snprintf(
                 wlast_err, sizeof(wlast_err),
@@ -462,14 +486,23 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
             return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
           }
 
-          current_res = (fzl_walk_res_t){.type = retres.type, .error = false};
+          if (retres.type == FZL_TYPE_OBJECT)
+            returning_object = true;
+
+          current_res = (fzl_walk_res_t){.type      = retres.type,
+                                         .error     = false,
+                                         .classname = retres.classname};
         }
         else
           current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
 
         for (size_t i = 0; i < (walker->sym_top - walker->ctx->initial_env_lvl);
              i++)
+        {
+          if (returning_object)
+            push_op(walker, FZL_OPCODE_ESCAPE_OBJECT);
           push_op(walker, FZL_OPCODE_RM_ENVTABLE);
+        }
         push_op(walker, FZL_OPCODE_RET);
         break;
       }
@@ -500,7 +533,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         if (right.error)
           return right;
 
-        if (!is_compatible(left.type, right.type))
+        if (!is_compatible(left.type, right.type, left.classname,
+                           right.classname))
         {
           snprintf(wlast_err, sizeof(wlast_err),
                    "'%s': incompatible types at %ld:%ld", node->token->filename,
@@ -508,6 +542,46 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
           return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
         }
 
+        if (left.type == FZL_TYPE_STRING && right.type == FZL_TYPE_STRING)
+        {
+          switch (node->type)
+          {
+            case FZL_NODETYPE_EQUAL:
+              push_op(walker, FZL_OPCODE_CMP_EQ_STR);
+              break;
+
+            case FZL_NODETYPE_NEQUAL:
+              push_op(walker, FZL_OPCODE_CMP_NEQ_STR);
+              break;
+
+            default:
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "'%s': unsupported strings operation at %ld:%ld",
+                       node->token->filename, node->token->ln, node->token->cn);
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+          }
+        }
+        else if (left.type == FZL_TYPE_OBJECT && right.type == FZL_TYPE_OBJECT)
+        {
+          switch (node->type)
+          {
+            case FZL_NODETYPE_EQUAL:
+              push_op(walker, FZL_OPCODE_CMP_EQ_OBJ);
+              break;
+
+            case FZL_NODETYPE_NEQUAL:
+              push_op(walker, FZL_OPCODE_CMP_NEQ_OBJ);
+              break;
+
+            default:
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "'%s': unsupported object operation at %ld:%ld",
+                       node->token->filename, node->token->ln, node->token->cn);
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+          }
+        }
+        else
+        {
           switch (node->type)
           {
             case FZL_NODETYPE_EQUAL:
@@ -531,8 +605,9 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
             default:
               break;
           }
+        }
 
-        current_res = (fzl_walk_res_t){.type = left.type, .error = false};
+        current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
         break;
       }
 
@@ -547,7 +622,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         if (right.error)
           return right;
 
-        if (!is_compatible(left.type, right.type))
+        if (!is_compatible(left.type, right.type, left.classname,
+                           right.classname))
         {
           snprintf(wlast_err, sizeof(wlast_err),
                    "'%s': incompatible types at %ld:%ld", node->token->filename,
@@ -560,7 +636,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         else
           push_op(walker, FZL_OPCODE_OR);
 
-        current_res = (fzl_walk_res_t){.type = left.type, .error = false};
+        current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
         break;
       }
 
@@ -678,6 +754,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)
@@ -702,8 +802,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'",
+                       "'%s': call to unknown function '%s' at %ld:%ld",
-                       (char *)node->token->value);
+                       node->token->filename, (char *)node->token->value,
+                       node->token->ln, node->token->cn);
               return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
             }
 
@@ -717,85 +818,74 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
             push_op(walker, FZL_OPCODE_CALL);
             push_word(walker, res.ip);
 
-            current_res = (fzl_walk_res_t){.type = res.type, .error = false};
+            current_res = (fzl_walk_res_t){
+                .type = res.type, .error = false, .classname = res.classname};
           }
           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;
+            fzl_walk_res_t parent_res = walk(walker, parent_node);
-            bool found = false;
+            if (parent_res.error)
-            for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
+              return parent_res;
-              if ((found = fzl_symt_get(walker->syms[i],
-                                        parent_node->token->value, &res)))
-                break;
 
-            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",
+                       "'%s': cannot call method on non-object type at %ld:%ld",
-                       node->token->filename, (char *)parent_node->token->value,
+                       parent_node->token->filename, parent_node->token->ln,
-                       node->token->ln, node->token->cn);
+                       parent_node->token->cn);
               return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
             }
 
-            if (res.type != FZL_TYPE_OBJECT || !res.classname)
+            char *classname   = parent_res.classname;
+            bool class_exists = false;
+            for (size_t i = 0; i < walker->classes_count; i++)
+            {
+              if (strcmp(classname, walker->classes[i]->name) == 0)
+              {
+                class_exists = true;
+                break;
+              }
+            }
+
+            if (!class_exists)
             {
               snprintf(wlast_err, sizeof(wlast_err),
-                       "'%s': name '%s' is not an object (at %ld:%ld)",
+                       "'%s': class '%s' not found (at %ld:%ld)",
-                       parent_node->token->filename,
+                       parent_node->token->filename, classname,
-                       (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;
+            size_t classlen  = strlen(classname);
-            for (size_t i = 0; i < walker->classes_count; i++)
+            size_t fnlen     = strlen(method_node->token->value);
-            {
-              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, 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};
             }
-
+            free(methodname);
-            fzl_walk_res_t parent = walk(walker, parent_node);
-            if (parent.error)
-              return parent;
 
             if (node->call.args_count > 0)
             {
@@ -808,9 +898,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};
+            current_res = (fzl_walk_res_t){.type      = fn_sym.type,
+                                           .error     = false,
+                                           .classname = fn_sym.classname};
           }
         }
         break;
@@ -845,6 +937,15 @@ 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)
+        {
+          fzl_token_t *tok = node->token;
+          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:
@@ -972,7 +1073,9 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         push_op(walker, FZL_OPCODE_LOADCONST);
         push_word(walker, const_n);
 
-        current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
+        current_res = (fzl_walk_res_t){.type      = FZL_TYPE_NULL,
+                                       .error     = false,
+                                       .classname = node->var.type->value};
         break;
       }
 
@@ -1009,14 +1112,15 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
 
           if (!found)
           {
-            fzl_token_t *tok = node->binary_op.left->token->value;
+            fzl_token_t *tok = node->binary_op.left->token;
             snprintf(wlast_err, sizeof(wlast_err),
                      "'%s': name '%s' is not exists at %ld:%ld", tok->filename,
                      (char *)tok->value, tok->ln, tok->cn);
             return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
           }
 
-          if (!is_compatible(sym.type, rres.type))
+          if (!is_compatible(sym.type, rres.type, sym.classname,
+                             rres.classname))
           {
             fzl_token_t *tok = node->binary_op.right->token;
             snprintf(wlast_err, sizeof(wlast_err),
@@ -1091,7 +1195,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
           return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
         }
 
-        current_res = (fzl_walk_res_t){.type = rres.type, .error = false};
+        current_res = (fzl_walk_res_t){
+            .type = rres.type, .error = false, .classname = rres.classname};
         break;
       }
     }

src/vm/fzl_vm.c

@@ -33,12 +33,10 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
   vm->dtop         = 0;
   vm->ctop         = 0;
   vm->etop         = 0;
-  vm->objects_count = 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)
@@ -110,6 +108,162 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
   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)
+  {
+    printf("<null>\n");
+    return;
+  }
+
+  printf("obj<");
+  for (size_t i = 0; i < obj->values_count; i++)
+  {
+    fzl_value_t arg = obj->values[i];
+
+    if (i > 0)
+      printf(", ");
+
+    if (arg.type == FZL_TYPE_STRING)
+      printf("str(%s)", arg.as.s.value);
+    else if (arg.type == FZL_TYPE_CHAR)
+      printf("char(%c)", arg.as.c);
+    else if (arg.type == FZL_TYPE_INT)
+      printf("int(%ld)", arg.as.i);
+    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);
+    else if (arg.type == FZL_TYPE_NULL)
+      printf("<null>");
+    else if (arg.type == FZL_TYPE_OBJECT)
+      print_object(arg.as.obj);
+    else
+      printf("<unknown>");
+  }
+
+  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)
@@ -125,6 +279,141 @@ 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];
+        fzl_value_t right = vm->dstack[--vm->dtop];
+
+        int result = strcmp(left.as.s.value, right.as.s.value);
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = result == 0};
+        break;
+      }
+
+      case FZL_OPCODE_CMP_NEQ_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];
+        fzl_value_t right = vm->dstack[--vm->dtop];
+
+        int result = strcmp(left.as.s.value, right.as.s.value);
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = result != 0};
+        break;
+      }
+
+      case FZL_OPCODE_CMP_EQ_OBJ:
+      {
+        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];
+        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};
+        break;
+      }
+
+      case FZL_OPCODE_CMP_NEQ_OBJ:
+      {
+        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];
+        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};
+        break;
+      }
+
+      case FZL_OPCODE_ESCAPE_OBJECT:
+      {
+        if (vm->dtop < 1)
+        {
+          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];
+        if (obj.type != FZL_TYPE_OBJECT)
+        {
+          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 (vm->etop < 2)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - cannot escape object from global env");
+          print_err_data(vm);
+          return -1;
+        }
+
+        escape_recursive(current, parent, obj.as.obj);
+        vm->dstack[vm->dtop++] = obj;
+
+        break;
+      }
+
       case FZL_OPCODE_ALLOC_OBJECT:
       {
         uint64_t values_count = vm->ops[++vm->ip];
@@ -132,7 +421,17 @@ int fzl_vm_run(fzl_vm_t *vm)
         obj->values           = malloc(values_count * sizeof(fzl_value_t));
         obj->values_count     = values_count;
 
-        vm->objects[vm->objects_count++] = obj;
+        fzl_vm_env_t *current_env = vm->estack[vm->etop - 1];
+        if (current_env->owned_objects_remainder <=
+            current_env->owned_objects_count)
+        {
+          current_env->owned_objects_remainder *= 2;
+          current_env->owned_objects = realloc(
+              current_env->owned_objects,
+              current_env->owned_objects_remainder * sizeof(fzl_vm_object_t *));
+        }
+
+        current_env->owned_objects[current_env->owned_objects_count++] = obj;
         vm->dstack[vm->dtop++] =
             (fzl_value_t){.type = FZL_TYPE_OBJECT, .as.obj = obj};
         break;
@@ -144,6 +443,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;
         }
 
@@ -155,6 +455,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;
         }
 
@@ -163,6 +464,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;
         }
 
@@ -176,6 +478,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;
         }
 
@@ -188,6 +491,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;
         }
 
@@ -196,6 +500,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;
         }
 
@@ -217,6 +522,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;
         }
 
@@ -229,6 +535,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;
         }
 
@@ -243,6 +550,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;
         }
 
@@ -257,6 +565,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;
         }
 
@@ -271,6 +580,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;
         }
 
@@ -285,6 +595,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;
         }
 
@@ -299,6 +610,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;
         }
 
@@ -313,6 +625,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;
         }
 
@@ -326,6 +639,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;
         }
 
@@ -344,6 +658,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;
         }
 
@@ -358,6 +673,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;
         }
 
@@ -372,6 +688,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;
         }
 
@@ -386,14 +703,28 @@ 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(
+        char *wrname = (char *)writevar.as.s.value;
-            vm->estack[vm->etop - 1], (char *)writevar.as.s.value, 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;
+          }
+        }
+
+        fzl_vm_env_wresult_t wresult =
+            fzl_env_writevalue(vm->estack[wrlvl], (char *)wrname, value);
         if (wresult != FZL_VM_ENV_WRESULT_OK)
         {
           switch (wresult)
@@ -401,21 +732,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;
           }
         }
@@ -439,6 +774,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;
         }
 
@@ -474,11 +810,19 @@ int fzl_vm_run(fzl_vm_t *vm)
             printf("%b\n", arg.as.b);
           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];
+          exit(arg.as.i);
         }
         else
         {
           snprintf(last_err, sizeof(last_err),
                    "runtime error - undefined builtin %lu", fn_id);
+          print_err_data(vm);
           return -1;
         }
       }
@@ -490,6 +834,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];
@@ -505,6 +850,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];
@@ -518,6 +864,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];
@@ -531,6 +878,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];
@@ -544,6 +892,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];
@@ -557,6 +906,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];
@@ -577,6 +927,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];
@@ -590,6 +941,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];
@@ -616,6 +968,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;
     }
 
@@ -638,12 +991,6 @@ void fzl_freevm(fzl_vm_t *vm)
       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);

src/vm/fzl_vm_debug.c

@@ -20,6 +20,30 @@ 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;
+
+      case FZL_OPCODE_CMP_NEQ_STR:
+        printf("CMP_NEQ_STR\n");
+        break;
+
+      case FZL_OPCODE_CMP_EQ_OBJ:
+        printf("CMP_EQ_OBJ\n");
+        break;
+
+      case FZL_OPCODE_CMP_NEQ_OBJ:
+        printf("CMP_NEQ_OBJ\n");
+        break;
+
+      case FZL_OPCODE_ESCAPE_OBJECT:
+        printf("ESCAPE_OBJ\n");
+        break;
+
       case FZL_OPCODE_ALLOC_OBJECT:
         printf("ALLOC_OBJECT: %lu fields\n", vm->ops[++i]);
         break;

src/vm/fzl_vm_env.c

@@ -1,3 +1,4 @@
+#include "vm/fzl_vm_object.h"
 #include <common/fzl_types.h>
 #include <common/fzl_value.h>
 #include <stdbool.h>
@@ -15,6 +16,11 @@ fzl_vm_env_t *fzl_mkenv()
   env->size         = 0;
   env->table        = malloc(env->remainder * sizeof(fzl_vm_env_entry_t));
 
+  env->owned_objects_remainder = 2;
+  env->owned_objects_count     = 0;
+  env->owned_objects =
+      malloc(env->owned_objects_remainder * sizeof(fzl_vm_object_t *));
+
   return env;
 }
 
@@ -96,5 +102,21 @@ void fzl_freeenv(fzl_vm_env_t *env)
   if (env->table)
     free(env->table);
 
+  if (env->owned_objects)
+  {
+    for (size_t i = 0; i < env->owned_objects_count; i++)
+    {
+      if (!env->owned_objects[i])
+        continue;
+
+      if (env->owned_objects[i]->values)
+        free(env->owned_objects[i]->values);
+
+      free(env->owned_objects[i]);
+    }
+
+    free(env->owned_objects);
+  }
+
   free(env);
 }