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
48 changed files with 3005 additions and 729 deletions
@@ -2,4 +2,14 @@ skip peek
 skip consume
 skip next
 skip is
+skip -rfunction fzl_mk*
+skip -rfunction fzl_free*
+skip -rfunction fzl_symt*
+skip add_const
+skip push_op
+skip push_word
+skip -rfunction fzl_env*
+skip tok_to_type
+skip nest_ctx
+skip fin_ctx

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

@@ -16,6 +22,9 @@ add_executable(fzc
 	src/compiler/fzl_writer.c
 	src/compiler/utils/fzl_const_pool.c
 	src/compiler/utils/fzl_symtable.c
+	src/compiler/utils/fzl_linked.c
+	src/compiler/utils/fzl_options.c
+	src/compiler/utils/fzl_ctable.c
 	src/compiler/main.c)

 # Virtual machine
@@ -59,6 +68,26 @@ add_test(
 	NAME compile_fn
 	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/fn.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/fn.fzs"
 )
+add_test(
+	NAME compile_comment
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/comment.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/comment.fzs"
+)
+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)

@@ -90,4 +119,24 @@ add_test(
 	NAME runtime_fn
 	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/fn.fzb"
 )
+add_test(
+	NAME runtime_comment
+	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/comment.fzb"
+)
+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"
+)

@@ -18,6 +18,8 @@ At the moment, the language has the following capabilities:
  - `str` - strings
  - `bool` - boolean
 - Assignments
+- Functions
+- Classes and objects

 Working examples of code can be found in `exl/` directory.

@@ -51,8 +53,9 @@ This file provides set up codestyle rules.
 There is two targets in Makefile for debugging purposes: `build-c` for the compiler and `build-vm` for the VM.
 Each target can be called with `FILE` variable. For example:

-
 ```shell
 $ make debug-c FILE=exl/hw.fzs
 ```

+To test new features, use `test` make target and the tests, defined in `CMakeLists.txt`.
+
@@ -9,7 +9,7 @@
 На данный момент язык имеет:

 - Встроенную функцию `printline` для вывода аргумента в stdout
- Строковый и числовой литералы
+- Строковый, булев и числовой литералы
 - Арифметические операции: сложение, вычитание, умножение, деление, модуло, возведение в степень
 - Декларация переменных со следующими типами:
  - `uint`, `int` - целые числа размером с машинное слово
@@ -18,6 +18,8 @@
  - `str` - строки
  - `bool` - булевы
 - Присваивание
+- Функции
+- Классы и объекты

 Примеры кода лежат в директории `exl/`.

@@ -55,3 +57,5 @@
 $ make debug-c FILE=exl/hw.fzs
 ```

+Для проверки новых фич, нужно использовать make-таргет `test`, а тесты писать в `CMakeLists.txt`.
+
@@ -1,7 +1,7 @@
-printline(2 + 2 * 2)
-printline(-1 + 1)
-printline(2 ^ 2)
-printline(1 + 1 * 1 / 1)
-printline(4 % 2)
-printline(10 / 2)
+printline(2 + 2 * 2);
+printline(-1 + 1);
+printline(2 ^ 2);
+printline(1 + 1 * 1 / 1);
+printline(4 % 2);
+printline(10 / 2);

@@ -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);
+
@@ -0,0 +1,36 @@
+class Point
+{
+  int x;
+  int y;
+
+  // Move point by [dx,dy]
+  fn move(int dx, int dy) {
+    this.x = this.x + dx;
+    this.y = this.y + dy;
+  }
+}
+
+Point obj = new Point;
+obj.x = 1;
+obj.y = 2;
+
+printline("Current X,Y:");
+printline(obj.x);
+printline(obj.y);
+
+// NOTE: WHY THE FUCK THIS FUCKING COMPILER REQUIRES ';' AFTER '='?!
+//      |
+//      v
+obj.move(9, 8);
+printline("X,Y after move:");
+printline(obj.x);
+printline(obj.y);
+
+if (obj.x == 10 && obj.y == 10)
+  printline("Test passed");
+else
+{
+  printline("Test failed");
+  exit(1);
+}
+
@@ -0,0 +1,3 @@
+// I'm a comment
+printline("Comment is skipped");;;;;
+
@@ -1,16 +1,20 @@
-bool flag = true
+bool flag = true;

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

 {
-  printline("block after")
+  printline("block after");
 }

@@ -1,24 +1,32 @@
-int fib(int n)
+fn fib(int n) int
 {
  if (n <= 1)
-    return n
+    return n;

-  return fib(n - 1) + fib(n - 2)
+  return fib(n - 1) + fib(n - 2);
 }

-uint sum(uint a, uint b)
+fn sum(uint a, uint b) uint
 {
-  return a + b
+  return a + b;
 }

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

-printline("Test #2: sum")
+printline("Test #2: sum");
 if (sum(2, 2) == 4)
-  printline("Sum test passed")
-else printline("Sum test failed")
+  printline("Sum test passed");
+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);
+}
+
@@ -1,2 +1,2 @@
-printline('hello, world')
+printline('hello, world');

@@ -1 +1 @@
-printline("")
+printline("");
@@ -1 +1 @@
-printline("hello)
+printline("hello);
@@ -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);
+}
+
@@ -1,13 +1,13 @@
-uint work_it = 21 * 2 ^ 2
-int  make_it = 10 
+uint work_it = 21 * 2 ^ 2;
+int  make_it = 10;

-u64  do_it
-do_it = 15
+u64  do_it;
+do_it = 15;

-printline(work_it)
-printline(make_it + do_it)
+printline(work_it);
+printline(make_it + do_it);

-char make_us
-str floyd = "hello, Pink Floyd!"
-printline(floyd)
+char make_us;
+str floyd = "hello, Pink Floyd!";
+printline(floyd);

@@ -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
@@ -0,0 +1,10 @@
+#ifndef FZL_COLORS_H
+#define FZL_COLORS_H
+
+#define FZL_CERROR "\033[0;31m"
+#define FZL_CWARNING "\033[0;33m"
+#define FZL_COK "\033[0;32m"
+#define FZL_CDEBUG "\033[0;34m"
+#define FZL_CRST "\033[0m"
+
+#endif // FZL_COLORS_H
@@ -21,6 +21,12 @@ typedef enum
  FZL_OPCODE_CALL = 0xF30001, // Call function
  FZL_OPCODE_RET  = 0xF30002, // Return from function

+  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
  FZL_OPCODE_MUL = 0xA00003, // Multiply two numbers in dstack
@@ -36,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

@@ -4,6 +4,7 @@
 typedef enum
 {
  FZL_TYPE_NULL,
+  FZL_TYPE_OBJECT,

  FZL_TYPE_STRING,
  FZL_TYPE_CHAR,
@@ -13,6 +13,8 @@ typedef struct

  union
  {
+    void *obj;
+
    struct
    {
      const char *value;
@@ -1,7 +1,6 @@
 #ifndef FZL_PARSER_H
 #define FZL_PARSER_H

-#include "common/fzl_types.h"
 #include <compiler/fzl_reader.h>
 #include <compiler/fzl_token.h>
 #include <stddef.h>
@@ -16,6 +15,9 @@ typedef enum
  FZL_NODETYPE_CONDITIONAL,
  FZL_NODETYPE_FUNCTION,
  FZL_NODETYPE_RETURN,
+  FZL_NODETYPE_CLASS,
+  FZL_NODETYPE_FIELD,
+  FZL_NODETYPE_CONSTRUCT,

  FZL_NODETYPE_ADD,
  FZL_NODETYPE_SUB,
@@ -113,6 +115,31 @@ typedef struct fzl_node
    {
      struct fzl_node *value;
    } ret;
+
+    // Class declaration
+    struct
+    {
+      fzl_token_t *name;
+
+      struct fzl_node **fields;
+      size_t fields_count;
+
+      struct fzl_node **methods;
+      size_t methods_count;
+    } class;
+
+    // Member access
+    struct
+    {
+      struct fzl_node *parent;
+      struct fzl_node *field;
+    } memb;
+
+    // Object construct
+    struct
+    {
+      struct fzl_node *name;
+    } construct;
  };
 } fzl_node_t;

@@ -2,6 +2,7 @@
 #define FZL_READER_H

 #include <compiler/fzl_token.h>
+#include <compiler/utils/fzl_linked.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -19,16 +20,16 @@ typedef struct
  fzl_reader_ll_t *first;
  fzl_reader_ll_t *last;

+  fzl_linked_t *linked;
+
  char *source;
  size_t size;

  size_t position;
-  size_t line_start;
-  size_t line_n;
 } fzl_reader_t;

 // Allocate new reader
-fzl_reader_t *fzl_mkreader(char *source);
+fzl_reader_t *fzl_mkreader(fzl_linked_t *linked);

 // Read source file
 int fzl_read(fzl_reader_t *reader);
@@ -8,6 +8,10 @@
 // Token type
 typedef enum
 {
+  FZL_TOKTYPE_CLASS, // class
+  FZL_TOKTYPE_NEW,   // new
+
+  FZL_TOKTYPE_FUNCTION, // fn
  FZL_TOKTYPE_RETURN,   // return

  FZL_TOKTYPE_IF,   // if
@@ -16,6 +20,8 @@ typedef enum
  FZL_TOKTYPE_NAME, // abc
  FZL_TOKTYPE_TYPE, // i16

+  FZL_TOKTYPE_DDASH, // // :D
+
  FZL_TOKTYPE_LPAREN, // (
  FZL_TOKTYPE_RPAREN, // )
  FZL_TOKTYPE_LBRACE, // {
@@ -28,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,      // ||
@@ -59,11 +66,12 @@ typedef struct
  bool store_value;
  void *value;
  uint16_t value_sz;
+  char *filename;
 } fzl_token_t;

 // Allocate new token
 fzl_token_t *fzl_mktoken(const fzl_toktype_t type, size_t line, size_t col,
-                         void *value, size_t value_sz);
+                         void *value, size_t value_sz, char *filename);

 // Free token and its contents
 void fzl_freetoken(fzl_token_t *token);
@@ -5,10 +5,20 @@
 #include <common/fzl_types.h>
 #include <compiler/fzl_parser.h>
 #include <compiler/utils/fzl_const_pool.h>
+#include <compiler/utils/fzl_ctable.h>
 #include <compiler/utils/fzl_symtable.h>
 #include <stdbool.h>
 #include <stddef.h>

+// Type of context
+typedef enum
+{
+  FZL_WALK_CTX_TYPE_GLOBAL,
+  FZL_WALK_CTX_TYPE_FN,
+  FZL_WALK_CTX_TYPE_CLASS,
+  FZL_WALK_CTX_TYPE_ASSIGN
+} fzl_walk_ctx_type_t;
+
 // Internal walk function result
 typedef struct
 {
@@ -16,11 +26,16 @@ typedef struct

  char *error_msg;
  bool error;
+
+  char *classname;
 } fzl_walk_res_t;

 // Function context descriptor
-typedef struct
+typedef struct fzl_walk_ctx
 {
+  fzl_walk_ctx_type_t type;
+  struct fzl_walk_ctx *parent;
+
  fzl_node_t *fn;
  size_t initial_env_lvl;
 } fzl_walk_ctx_t;
@@ -39,6 +54,9 @@ typedef struct
  size_t sym_top;

  fzl_walk_ctx_t *ctx;
+
+  fzl_ctable_t *classes[64];
+  size_t classes_count;
 } fzl_walker_t;

 // Allocate new walker
@@ -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);
@@ -0,0 +1,30 @@
+#ifndef FZL_CTABLE_H
+#define FZL_CTABLE_H
+
+#include <common/fzl_types.h>
+#include <stddef.h>
+
+// Class field descriptor
+typedef struct
+{
+  char *name;
+  size_t slot_index;
+  fzl_type_t type;
+} fzl_ctable_field_t;
+
+// Class table descriptor
+typedef struct
+{
+  char *name;
+  fzl_ctable_field_t *fields;
+  size_t fields_count;
+  size_t fields_remainder;
+} fzl_ctable_t;
+
+// Allocate class table
+fzl_ctable_t *fzl_mkctable(char *name);
+
+// Free class table
+void fzl_freectable(fzl_ctable_t *ct);
+
+#endif // FZL_CTABLE_H
@@ -0,0 +1,49 @@
+#ifndef FZL_LINKED_H
+#define FZL_LINKED_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+// Linked file descriptor
+typedef struct
+{
+  char *name;
+  size_t start;
+  size_t end;
+} fzl_linked_entry_t;
+
+// Linked descriptor
+typedef struct
+{
+  fzl_linked_entry_t *entries;
+  size_t entries_count;
+
+  char *source;
+  size_t total_sz;
+} fzl_linked_t;
+
+// Position in file
+typedef struct
+{
+  size_t line;
+  size_t col;
+
+  char *filename;
+} fzl_file_loc;
+
+// Allocated new linked
+fzl_linked_t *fzl_mklinked();
+
+// Read specified files
+bool fzl_linked_add_files(fzl_linked_t *l, char **files, size_t files_count);
+
+// Get last error from linked
+char *fzl_linked_geterror();
+
+// Get filename and position in it by reader cursor
+bool fzl_linked_getpos(fzl_linked_t *l, size_t pos, fzl_file_loc *res);
+
+// Free linked obj
+void fzl_freelinked(fzl_linked_t *linked);
+
+#endif // FZL_LINKED_H
@@ -0,0 +1,25 @@
+#ifndef FZL_OPTIONS_H
+#define FZL_OPTIONS_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+// Compiler options
+typedef struct
+{
+  char **files;
+  size_t files_count;
+
+  char *outname;
+
+  bool should_continue;
+  bool verbose;
+} fzl_options_t;
+
+// Parse command line arguments
+fzl_options_t *fzl_mkoptions(int argc, char **argv);
+
+// Free options
+void fzl_freeoptions(fzl_options_t *options);
+
+#endif // FZL_OPTIONS_H
@@ -10,7 +10,8 @@ typedef enum
 {
  FZL_SYMTABLE_RESULT_OK,
  FZL_SYMTABLE_RESULT_ERR,
-  FZL_SYMTABLE_RESULT_EXISTS
+  FZL_SYMTABLE_RESULT_EXISTS,
+  FZL_SYMTABLE_RESULT_NOT_OBJECT
 } fzl_symtable_res_t;

 // Symbols table entry descriptor
@@ -19,6 +20,8 @@ typedef struct
  char *name;
  fzl_type_t type;
  size_t ip;
+
+  char *classname;
 } fzl_sym_t;

 // Symbols table descriptor
@@ -37,6 +40,10 @@ fzl_symtable_t *fzl_mksymt();
 fzl_symtable_res_t fzl_symt_put(fzl_symtable_t *symt, char *name,
                                fzl_type_t type, uint64_t ip);

+// Assign class name to object type
+fzl_symtable_res_t fzl_symt_setobjclass(fzl_symtable_t *symt, char *name,
+                                        char *classname);
+
 // Get entry from specified symtable
 bool fzl_symt_get(fzl_symtable_t *symt, char *name, fzl_sym_t *res);

@@ -6,6 +6,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <vm/fzl_vm_env.h>
+#include <vm/fzl_vm_object.h>

 // VM descriptor
 typedef struct
@@ -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
@@ -0,0 +1,14 @@
+#ifndef FZL_VM_OBJECT_H
+#define FZL_VM_OBJECT_H
+
+#include <common/fzl_value.h>
+#include <stddef.h>
+
+// Object descriptor
+typedef struct
+{
+  fzl_value_t *values;
+  size_t values_count;
+} fzl_vm_object_t;
+
+#endif // FZL_VM_OBJECT_H
@@ -27,11 +27,31 @@ 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)
  {
+    case FZL_NODETYPE_CONSTRUCT:
+      printf("%s Construct class '%s':\n", levelbuf,
+             (char *)node->construct.name->token->value);
+      break;
+
+    case FZL_NODETYPE_CLASS:
+      printf("%s Class '%s':\n", levelbuf, (char *)node->token->value);
+      printf("-%s Fields:\n", levelbuf);
+      for (size_t i = 0; i < node->class.fields_count; i++)
+        print_node(node->class.fields[i], level + 2);
+      printf("-%s Methods:\n", levelbuf);
+      for (size_t i = 0; i < node->class.methods_count; i++)
+        print_node(node->class.methods[i], level + 2);
+      break;
+
+    case FZL_NODETYPE_FIELD:
+      printf("%s Field '%s' access:\n", levelbuf,
+             (char *)node->memb.field->token->value);
+      print_node(node->memb.parent, level + 1);
+      break;
+
    case FZL_NODETYPE_DECLARATION:
      printf("%s Declare variable with type %d:\n", levelbuf,
             node->var.type->type);
@@ -112,6 +132,8 @@ void print_node(fzl_node_t *node, int level)
        print_node(node->ret.value, level + 1);
      break;

+    case FZL_NODETYPE_AND:
+    case FZL_NODETYPE_OR:
    case FZL_NODETYPE_EQUAL:
    case FZL_NODETYPE_NEQUAL:
    case FZL_NODETYPE_LESS:
@@ -7,6 +7,25 @@
 #include <string.h>

 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)
 {
@@ -34,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;
@@ -50,27 +70,17 @@ static fzl_token_t *peek(fzl_parser_t *parser)
 {
  if (!parser || !parser->cursor)
    return NULL;
+
+  last_known_tok = parser->cursor->token;
  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)
 {
-  if (!parser || !parser->cursor)
+  if (!parser || !parser->cursor || !parser->cursor->token)
    return NULL;
+
  fzl_token_t *tok = parser->cursor->token;
  parser->cursor   = parser->cursor->next;
  return tok;
@@ -136,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);
@@ -157,8 +160,8 @@ fzl_node_t *parse_primary(fzl_parser_t *parser)
    fzl_node_t *node = parse_expression(parser);
    if (!is(parser, FZL_TOKTYPE_RPAREN))
    {
-      snprintf(plast_err, sizeof(plast_err), "expected ')' at %ld:%ld",
-               parser->cursor->token->ln, parser->cursor->token->cn);
+      snprintf(plast_err, sizeof(plast_err), "'%s': expected ')' at %ld:%ld",
+               peek(parser)->filename, peek(parser)->ln, peek(parser)->cn);
      return NULL;
    }
    consume(parser);
@@ -167,10 +170,36 @@ fzl_node_t *parse_primary(fzl_parser_t *parser)
  else if (is(parser, FZL_TOKTYPE_NAME))
  {
    fzl_token_t *name = consume(parser);
+    if (!is(parser, FZL_TOKTYPE_NAME))
      return fzl_mknode(FZL_NODETYPE_IDENTIFIER, name);
+
+    fzl_token_t *realname = consume(parser); // :D
+    fzl_node_t *decl      = fzl_mknode(FZL_NODETYPE_DECLARATION, name);
+    decl->var.type        = name;
+    decl->var.identifier  = fzl_mknode(FZL_NODETYPE_IDENTIFIER, realname);
+    return decl;
+  }
+  else if (is(parser, FZL_TOKTYPE_TYPE))
+  {
+    fzl_token_t *type = consume(parser);
+    fzl_token_t *name = consume(parser);
+    if (name->type != FZL_TOKTYPE_NAME)
+    {
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': expected name after type at %ld:%ld", type->filename,
+               type->ln, type->cn);
+      return NULL;
    }

-  snprintf(plast_err, sizeof(plast_err), "failed to parse primary at %ld:%ld",
+    fzl_node_t *decl     = fzl_mknode(FZL_NODETYPE_DECLARATION, type);
+    decl->var.type       = type;
+    decl->var.identifier = fzl_mknode(FZL_NODETYPE_IDENTIFIER, name);
+    return decl;
+  }
+
+  if (!plast_err[0])
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': failed to parse primary at %ld:%ld", peek(parser)->filename,
             peek(parser)->ln, peek(parser)->cn);
  return NULL;
 }
@@ -182,19 +211,24 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
    return NULL;

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

  if (!left)
  {
-    snprintf(plast_err, sizeof(plast_err), "failed to parse postfix at %ld:%ld",
-             peek(parser)->ln, peek(parser)->cn);
+    if (!plast_err[0])
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': failed to parse postfix at %ld:%ld",
+               peek(parser)->filename, peek(parser)->ln, peek(parser)->cn);
    return NULL;
  }

-  while (is(parser, FZL_TOKTYPE_LPAREN))
+  if (is(parser, FZL_TOKTYPE_LPAREN) || is(parser, FZL_TOKTYPE_DOT))
  {
-    consume(parser);
+    while (is(parser, FZL_TOKTYPE_LPAREN) || is(parser, FZL_TOKTYPE_DOT))
+    {
+      fzl_token_t *post = consume(parser);

+      if (post->type == FZL_TOKTYPE_LPAREN)
+      {
        size_t args_capacity = 2;
        size_t args_count    = 0;
        fzl_node_t **args    = malloc(args_capacity * sizeof(fzl_node_t *));
@@ -211,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;
@@ -226,8 +260,8 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
        {
          free(args);
          snprintf(plast_err, sizeof(plast_err),
-               "expected ')' after argument list at %ld:%ld", peek(parser)->ln,
-               peek(parser)->cn);
+                   "'%s': expected ')' after argument list at %ld:%ld",
+                   peek(parser)->filename, peek(parser)->ln, peek(parser)->cn);
          return NULL;
        }

@@ -238,6 +272,26 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)

        left = node;
      }
+      else if (post->type == FZL_TOKTYPE_DOT)
+      {
+        if (!is(parser, FZL_TOKTYPE_NAME))
+        {
+          snprintf(plast_err, sizeof(plast_err),
+                   "'%s': expected name after '.' at %ld:%ld",
+                   last_known_tok->filename, last_known_tok->ln,
+                   last_known_tok->cn);
+          return NULL;
+        }
+
+        fzl_token_t *name = consume(parser);
+        fzl_node_t *node  = fzl_mknode(FZL_NODETYPE_FIELD, name);
+        node->memb.parent = left;
+        node->memb.field  = fzl_mknode(FZL_NODETYPE_IDENTIFIER, name);
+
+        left = node;
+      }
+    }
+  }

  return left;
 }
@@ -274,7 +328,9 @@ fzl_node_t *parse_power(fzl_parser_t *parser)

  if (!left)
  {
-    snprintf(plast_err, sizeof(plast_err), "failed to parse power at %ld:%ld",
+    if (!plast_err[0])
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': failed to parse power at %ld:%ld", peek(parser)->filename,
               peek(parser)->ln, peek(parser)->cn);
    return NULL;
  }
@@ -286,9 +342,10 @@ fzl_node_t *parse_power(fzl_parser_t *parser)
    right = parse_unary(parser);
    if (!right)
    {
+      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
-               "failed to parse right side of power at %ld:%ld",
-               peek(parser)->ln, peek(parser)->cn);
+                 "'%s': failed to parse right side of power at %ld:%ld",
+                 peek(parser)->filename, peek(parser)->ln, peek(parser)->cn);
      return NULL;
    }

@@ -314,8 +371,9 @@ fzl_node_t *parse_factor(fzl_parser_t *parser)
  if (!left)
  {
    if (!plast_err[0])
-      snprintf(plast_err, sizeof(plast_err), "invalid expression at %ld:%ld",
-               parser->cursor->token->ln, parser->cursor->token->cn);
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': invalid expression at %ld:%ld", peek(parser)->filename,
+               peek(parser)->ln, peek(parser)->cn);
    return NULL;
  }

@@ -327,9 +385,10 @@ fzl_node_t *parse_factor(fzl_parser_t *parser)
    right = parse_factor(parser);
    if (!right)
    {
+      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
-               "unfinished factor (mul/div) expression at %ld:%ld",
-               left->token->ln, left->token->cn);
+                 "'%s': unfinished factor (mul/div) expression at %ld:%ld",
+                 left->token->filename, left->token->ln, left->token->cn);
      return NULL;
    }

@@ -353,8 +412,10 @@ fzl_node_t *parse_term(fzl_parser_t *parser)

  if (!left)
  {
-    snprintf(plast_err, sizeof(plast_err), "invalid expression at %ld:%ld",
-             parser->cursor->token->ln, parser->cursor->token->cn);
+    if (!plast_err[0])
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': invalid expression at %ld:%ld", peek(parser)->filename,
+               peek(parser)->ln, peek(parser)->cn);
    return NULL;
  }

@@ -365,9 +426,10 @@ fzl_node_t *parse_term(fzl_parser_t *parser)
    right = parse_factor(parser);
    if (!right)
    {
+      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
-               "unfinished term (add/sub) expression at %ld:%ld",
-               left->token->ln, left->token->cn);
+                 "'%s': unfinished term (add/sub) expression at %ld:%ld",
+                 left->token->filename, left->token->ln, left->token->cn);
      return NULL;
    }

@@ -400,8 +462,10 @@ fzl_node_t *parse_cond(fzl_parser_t *parser)
    right           = parse_term(parser);
    if (!right)
    {
-      snprintf(plast_err, sizeof(plast_err), "unfinished expression at %ld:%ld",
-               op->ln, op->cn);
+      if (!plast_err[0])
+        snprintf(plast_err, sizeof(plast_err),
+                 "'%s': unfinished expression at %ld:%ld", op->filename, op->ln,
+                 op->cn);
      return NULL;
    }

@@ -456,8 +520,10 @@ fzl_node_t *parse_and(fzl_parser_t *parser)
    right            = parse_cond(parser);
    if (!right)
    {
-      snprintf(plast_err, sizeof(plast_err), "unfinished expression at %ld:%ld",
-               or->ln, or->cn);
+      if (!plast_err[0])
+        snprintf(plast_err, sizeof(plast_err),
+                 "'%s': unfinished expression at %ld:%ld", or->filename, or->ln,
+                 or->cn);
      return NULL;
    }

@@ -488,8 +554,10 @@ fzl_node_t *parse_or(fzl_parser_t *parser)
    right            = parse_and(parser);
    if (!right)
    {
-      snprintf(plast_err, sizeof(plast_err), "unfinished expression at %ld:%ld",
-               or->ln, or->cn);
+      if (!plast_err[0])
+        snprintf(plast_err, sizeof(plast_err),
+                 "'%s': unfinished expression at %ld:%ld", or->filename, or->ln,
+                 or->cn);
      return NULL;
    }

@@ -502,35 +570,238 @@ fzl_node_t *parse_or(fzl_parser_t *parser)
  return left;
 }

-// Expression parsing
-fzl_node_t *parse_expression(fzl_parser_t *parser) { return parse_and(parser); }
+// Object construct parsing
+fzl_node_t *parse_new(fzl_parser_t *parser)
+{
+  if (!is(parser, FZL_TOKTYPE_NEW))
+    return parse_or(parser);

-// Statement parsing
-fzl_node_t *parse_statement(fzl_parser_t *parser)
-{
-  if (is(parser, FZL_TOKTYPE_TYPE))
-  {
-    fzl_token_t *type = peek(parser);
-    if (type->type == FZL_TOKTYPE_TYPE)
-      consume(parser);
-
-    if (type->type == FZL_TOKTYPE_TYPE &&
-        next(parser)->type == FZL_TOKTYPE_LPAREN)
-    {
-      fzl_token_t *tok = consume(parser);
-      if (tok->type != FZL_TOKTYPE_NAME)
+  fzl_token_t *new    = consume(parser);
+  fzl_node_t *objname = parse_or(parser);
+  if (objname->type != FZL_NODETYPE_IDENTIFIER &&
+      objname->type != FZL_NODETYPE_FIELD)
  {
    snprintf(plast_err, sizeof(plast_err),
-                 "expected name in function definition at %ld:%ld", tok->ln,
-                 tok->cn);
+             "'%s': expect class name after 'new' keyword at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
    return NULL;
  }

-      fzl_token_t *lparen = consume(parser);
-      if (lparen->type != FZL_TOKTYPE_LPAREN)
+  fzl_node_t *node     = fzl_mknode(FZL_NODETYPE_CONSTRUCT, new);
+  node->construct.name = objname;
+
+  return node;
+}
+
+// Assignments parsing
+fzl_node_t *parse_assignment(fzl_parser_t *parser)
+{
+  fzl_node_t *left = parse_new(parser);
+  if (!left)
+    return NULL;
+
+  if (is(parser, FZL_TOKTYPE_EQ))
+  {
+    fzl_token_t *asn = consume(parser);
+    if (left->type != FZL_NODETYPE_IDENTIFIER &&
+        left->type != FZL_NODETYPE_DECLARATION &&
+        left->type != FZL_NODETYPE_FIELD)
    {
      snprintf(plast_err, sizeof(plast_err),
-                 "expected '(' after name at %ld:%ld", lparen->ln, lparen->cn);
+               "'%s': cannot assign to '%s' at %ld:%ld", left->token->filename,
+               (char *)left->token->value, asn->ln, asn->cn);
+      return NULL;
+    }
+
+    fzl_node_t *right = parse_assignment(parser);
+    if (!right)
+      return NULL;
+
+    fzl_node_t *node      = fzl_mknode(FZL_NODETYPE_ASSIGN, asn);
+    node->binary_op.left  = left;
+    node->binary_op.right = right;
+
+    left = node;
+  }
+
+  return left;
+}
+
+// Expression parsing
+fzl_node_t *parse_expression(fzl_parser_t *parser)
+{
+  return parse_assignment(parser);
+}
+
+fzl_node_t *parse_statement(fzl_parser_t *parser);
+
+// Parse class definition
+fzl_node_t *parse_class(fzl_parser_t *parser)
+{
+  if (!parser)
+    return NULL;
+
+  fzl_token_t *class = consume(parser);
+  fzl_token_t *name  = consume(parser);
+  if (name->type != FZL_TOKTYPE_NAME)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': expected class name at %ld:%ld", name->filename, name->ln,
+             name->cn);
+    return NULL;
+  }
+
+  fzl_token_t *lbrace = consume(parser);
+  if (lbrace->type != FZL_TOKTYPE_LBRACE)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': expected '{' after class name at %ld:%ld", lbrace->filename,
+             lbrace->ln, lbrace->cn);
+    return NULL;
+  }
+
+  size_t fremainder   = 2;
+  size_t fcount       = 0;
+  fzl_node_t **fields = malloc(fremainder * sizeof(fzl_node_t *));
+  if (!fields)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "failed to allocate space for class fields");
+    return NULL;
+  }
+
+  size_t mremainder    = 2;
+  size_t mcount        = 0;
+  fzl_node_t **methods = malloc(mremainder * sizeof(fzl_node_t *));
+  if (!methods)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "failed to allocate space for class fields");
+    free(fields);
+    return NULL;
+  }
+
+  while (!is(parser, FZL_TOKTYPE_RBRACE))
+  {
+    fzl_node_t *node = parse_statement(parser);
+    if (!node)
+      return NULL;
+
+    if (node->type == FZL_NODETYPE_DECLARATION)
+    {
+      if (fremainder <= fcount)
+      {
+        fremainder *= 2;
+        fields = realloc(fields, fremainder * sizeof(fzl_node_t *));
+        if (!fields)
+        {
+          snprintf(plast_err, sizeof(plast_err),
+                   "failed to resize fields array");
+          free(methods);
+          return NULL;
+        }
+      }
+
+      fields[fcount++] = node;
+    }
+    else if (node->type == FZL_NODETYPE_FUNCTION)
+    {
+      if (mremainder <= mcount)
+      {
+        mremainder *= 2;
+        methods = realloc(methods, mremainder * sizeof(fzl_node_t *));
+        if (!methods)
+        {
+          snprintf(plast_err, sizeof(plast_err),
+                   "failed to resize methods array");
+          free(fields);
+          return NULL;
+        }
+      }
+
+      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;
+      }
+
+      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
+    {
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': unknown type of class member at %ld:%ld",
+               node->token->filename, node->token->ln, node->token->cn);
+      free(fields);
+      free(methods);
+      return NULL;
+    }
+  }
+  fzl_token_t *rbra = consume(parser);
+  if (rbra->type != FZL_TOKTYPE_RBRACE)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': expected '}' after class definition at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    free(fields);
+    free(methods);
+    return NULL;
+  }
+
+  fzl_node_t *node          = fzl_mknode(FZL_NODETYPE_CLASS, class);
+  node->class.name          = name;
+  node->class.fields        = fields;
+  node->class.fields_count  = fcount;
+  node->class.methods       = methods;
+  node->class.methods_count = mcount;
+
+  return node;
+}
+
+// Functions parsing
+fzl_node_t *parse_function(fzl_parser_t *parser)
+{
+  if (!parser)
+    return NULL;
+
+  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)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': expected function name at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_token_t *lpar = consume(parser);
+  if (!lpar || lpar->type != FZL_TOKTYPE_LPAREN)
+  {
+    snprintf(plast_err, sizeof(plast_err), "'%s': expected '(' at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
    return NULL;
  }

@@ -540,7 +811,7 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)

  while (peek(parser) && !is(parser, FZL_TOKTYPE_RPAREN))
  {
-        fzl_node_t *arg = parse_statement(parser);
+    fzl_node_t *arg = parse_expression(parser);
    if (!arg)
      return NULL;

@@ -556,20 +827,27 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
      consume(parser);
  }

-      fzl_token_t *rparen = consume(parser);
-      if (rparen->type != FZL_TOKTYPE_RPAREN)
+  fzl_token_t *rpar = consume(parser);
+  if (!rpar || rpar->type != FZL_TOKTYPE_RPAREN)
  {
    snprintf(plast_err, sizeof(plast_err),
-                 "expected ')' after argument list at %ld:%ld", rparen->ln,
-                 rparen->cn);
+             "'%s': expected ')' after argument list at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
    return NULL;
  }

+  fzl_token_t *type = NULL;
+  if (is(parser, FZL_TOKTYPE_TYPE) || is(parser, FZL_TOKTYPE_NAME))
+    type = consume(parser);
+
+  if (!type)
+    type = &null_tok;
+
  if (!is(parser, FZL_TOKTYPE_LBRACE))
  {
-        fzl_token_t *tok = peek(parser);
-        snprintf(plast_err, sizeof(plast_err), "expected '{' at %ld:%ld",
-                 tok->ln, tok->cn);
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': expected '{' after function declaration at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
    return NULL;
  }

@@ -577,104 +855,49 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
  if (!body)
    return NULL;

-      fzl_node_t *node    = fzl_mknode(FZL_NODETYPE_FUNCTION, tok);
+  fzl_node_t *node    = fzl_mknode(FZL_NODETYPE_FUNCTION, name);
  node->fn.args       = args;
  node->fn.args_count = count;
  node->fn.body       = body;
-      node->fn.name       = tok;
+  node->fn.name       = name;
  node->fn.type       = type;

  return node;
 }

-    if (type->type == FZL_TOKTYPE_TYPE || next(parser)->type == FZL_TOKTYPE_EQ)
+// Return parsing
+fzl_node_t *parse_return(fzl_parser_t *parser)
 {
-
-      fzl_node_t *identifier = parse_primary(parser);
-      if (!identifier || identifier->type != FZL_NODETYPE_IDENTIFIER)
-      {
-        snprintf(plast_err, sizeof(plast_err), "expected identifier at %ld:%ld",
-                 type->ln, type->cn);
-        return NULL;
-      }
-
-      fzl_node_t *left     = fzl_mknode(FZL_NODETYPE_DECLARATION, type);
-      left->var.type       = type;
-      left->var.identifier = identifier;
-
-      if (!is(parser, FZL_TOKTYPE_EQ))
-        return left;
-
-      fzl_node_t *right;
-      while (is(parser, FZL_TOKTYPE_EQ))
-      {
-        fzl_token_t *asn = consume(parser);
-        right            = parse_expression(parser);
-        if (!right)
+  if (!parser)
    return NULL;

-        fzl_node_t *node      = fzl_mknode(FZL_NODETYPE_ASSIGN, asn);
-        node->binary_op.left  = left;
-        node->binary_op.right = right;
-
-        left = node;
-      }
-
-      return left;
-    }
-  }
-
-  if (is(parser, FZL_TOKTYPE_NAME) && next(parser)->type == FZL_TOKTYPE_EQ)
-  {
-    fzl_token_t *name = consume(parser);
-    fzl_node_t *left  = fzl_mknode(FZL_NODETYPE_IDENTIFIER, name);
-
-    while (is(parser, FZL_TOKTYPE_EQ))
-    {
-      fzl_token_t *eq = consume(parser);
-
-      fzl_node_t *right = parse_expression(parser);
-      if (!right)
-        return NULL;
-
-      fzl_node_t *assn      = fzl_mknode(FZL_NODETYPE_ASSIGN, eq);
-      assn->binary_op.left  = left;
-      assn->binary_op.right = right;
-
-      left = assn;
-    }
-
-    return left;
-  }
-
-  if (is(parser, FZL_TOKTYPE_RETURN))
-  {
  fzl_token_t *ret = consume(parser);
  fzl_node_t *node = fzl_mknode(FZL_NODETYPE_RETURN, ret);

-    if (is(parser, FZL_TOKTYPE_DOT))
+  if (!is(parser, FZL_TOKTYPE_SEMICOLON))
  {
-      consume(parser);
-      return node;
-    }
-
    fzl_node_t *retval = parse_expression(parser);
    if (!retval)
      return NULL;

    node->ret.value = retval;
+  }
+
  return node;
 }

-  if (is(parser, FZL_TOKTYPE_IF))
+fzl_node_t *parse_if(fzl_parser_t *parser)
 {
+  if (!parser)
+    return NULL;
+
  fzl_token_t *if_tok = consume(parser);
  fzl_token_t *lparen = consume(parser);
  if (lparen->type != FZL_TOKTYPE_LPAREN)
  {
    snprintf(plast_err, sizeof(plast_err),
-               "expected '(' before condition at %ld:%ld", lparen->ln,
-               lparen->cn);
+             "'%s': expected '(' before condition at %ld:%ld", lparen->filename,
+             lparen->ln, lparen->cn);
    return NULL;
  }

@@ -686,8 +909,8 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
  if (rparen->type != FZL_TOKTYPE_RPAREN)
  {
    snprintf(plast_err, sizeof(plast_err),
-               "expected ')' after condition at %ld:%ld", rparen->ln,
-               rparen->cn);
+             "'%s': expected ')' after condition at %ld:%ld", rparen->filename,
+             rparen->ln, rparen->cn);
    return NULL;
  }

@@ -712,8 +935,12 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
  return stmt_node;
 }

-  if (is(parser, FZL_TOKTYPE_LBRACE))
+// Block statement parsing
+fzl_node_t *parse_block(fzl_parser_t *parser)
 {
+  if (!parser)
+    return NULL;
+
  fzl_token_t *block_tok = consume(parser);

  size_t remainder   = 2;
@@ -735,10 +962,11 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
    stmts[count++] = node;
  }
  fzl_token_t *rbrace = consume(parser);
-    if (!rbrace || rbrace->type != FZL_TOKTYPE_RBRACE)
+  if (rbrace && rbrace->type != FZL_TOKTYPE_RBRACE)
  {
    snprintf(plast_err, sizeof(plast_err),
-               "missing '}' after block at %ld:%ld", rbrace->ln, rbrace->cn);
+             "'%s': missing '}' after block at %ld:%ld", rbrace->filename,
+             rbrace->ln, rbrace->cn);
    return NULL;
  }

@@ -748,12 +976,46 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
  return node;
 }

-  return parse_expression(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))
+    return parse_class(parser);
+  else if (is(parser, FZL_TOKTYPE_FUNCTION))
+    return parse_function(parser);
+  else if (is(parser, FZL_TOKTYPE_RETURN))
+    res = parse_return(parser);
+  else if (is(parser, FZL_TOKTYPE_IF))
+    return parse_if(parser);
+  else if (is(parser, FZL_TOKTYPE_LBRACE))
+    return parse_block(parser);
+
+  if (!res)
+    res = parse_expression(parser);
+
+  if (!is(parser, FZL_TOKTYPE_SEMICOLON))
+  {
+    snprintf(plast_err, sizeof(plast_err), "'%s': missing ';' at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+  while (is(parser, FZL_TOKTYPE_SEMICOLON))
+    consume(parser);
+
+  return res;
 }

 // 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;
@@ -787,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;
@@ -813,8 +1077,13 @@ void fzl_freeast(fzl_node_t *root)

  while (root)
  {
-    if (root->type == FZL_NODETYPE_BLOCK)
+    switch (root->type)
    {
+      case FZL_NODETYPE_IDENTIFIER:
+      case FZL_NODETYPE_LITERAL:
+        break;
+
+      case FZL_NODETYPE_BLOCK:
        if (root->list.entries)
        {
          for (size_t i = 0; i < root->list.entry_count; i++)
@@ -823,44 +1092,104 @@ void fzl_freeast(fzl_node_t *root)

          free(root->list.entries);
        }
-    }
-    else if (root->type == FZL_NODETYPE_CALL)
-    {
+        break;
+
+      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);
-      }
-    }
-    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)
-    {
+        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);
-    }
-    else if (root->type == FZL_NODETYPE_UNARY_PLUS ||
-             root->type == FZL_NODETYPE_UNARY_MINUS)
-    {
+        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);
-    }
-    else if (root->type == FZL_NODETYPE_FUNCTION)
-    {
+        break;
+
+      case 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]);
+            fzl_freeast(root->fn.args[i]);
        free(root->fn.args);
-      fzl_freenode(root->fn.body);
+        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;
    }

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

@@ -1,4 +1,5 @@
 #include "compiler/fzl_token.h"
+#include "compiler/utils/fzl_linked.h"
 #include <compiler/fzl_reader.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -9,7 +10,7 @@
 // Last error from reader
 static char last_err[256] = {0};

-fzl_reader_t *fzl_mkreader(char *source)
+fzl_reader_t *fzl_mkreader(fzl_linked_t *linked)
 {
  fzl_reader_ll_t *first_node = malloc(sizeof(fzl_reader_ll_t));
  first_node->token           = NULL;
@@ -18,11 +19,10 @@ fzl_reader_t *fzl_mkreader(char *source)
  fzl_reader_t *reader = malloc(sizeof(fzl_reader_t));
  reader->first        = first_node;
  reader->last         = first_node;
-  reader->source       = source;
-  reader->size         = strlen(source);
+  reader->linked       = linked;
+  reader->source       = linked->source;
+  reader->size         = linked->total_sz;
  reader->position     = 0;
-  reader->line_n       = 1;
-  reader->line_start   = 0;

  return reader;
 }
@@ -30,21 +30,12 @@ fzl_reader_t *fzl_mkreader(char *source)
 // --- Read zone ---

 // Move cursor forward
+// @deprecated
 static size_t move(fzl_reader_t *reader, size_t len)
 {
  if (!reader)
    return 0;

-  char *src = reader->source;
-  for (size_t i = 0; i < len; i++)
-  {
-    if (src[reader->position + i] == '\n')
-    {
-      reader->line_n++;
-      reader->line_start = reader->position + i + 1;
-    }
-  }
-
  return reader->position += len;
 }

@@ -71,17 +62,35 @@ fzl_token_t *parse_name(fzl_reader_t *reader)
  move(reader, size);

  fzl_token_t *tok;
-  size_t line = reader->line_n;
-  size_t pos  = start - reader->line_start;
+  fzl_file_loc l;
+  bool ok = fzl_linked_getpos(reader->linked, start, &l);
+  if (!ok)
+  {
+    snprintf(last_err, sizeof(last_err), "failed to locate line:col");
+    return NULL;
+  }

-  if (strcmp(value, "return") == 0)
-    tok = fzl_mktoken(FZL_TOKTYPE_RETURN, line, pos, value, size);
+  if (strcmp(value, "class") == 0)
+    tok =
+        fzl_mktoken(FZL_TOKTYPE_CLASS, l.line, l.col, value, size, l.filename);
+  else if (strcmp(value, "new") == 0)
+    tok = fzl_mktoken(FZL_TOKTYPE_NEW, l.line, l.col, value, size, l.filename);
+  else if (strcmp(value, "fn") == 0)
+    tok = fzl_mktoken(FZL_TOKTYPE_FUNCTION, l.line, l.col, value, size,
+                      l.filename);
+  else if (strcmp(value, "return") == 0)
+    tok =
+        fzl_mktoken(FZL_TOKTYPE_RETURN, l.line, l.col, value, size, l.filename);
  else if (strcmp(value, "if") == 0)
-    tok = fzl_mktoken(FZL_TOKTYPE_IF, line, pos, value, size);
+    tok = fzl_mktoken(FZL_TOKTYPE_IF, l.line, l.col, value, size, l.filename);
  else if (strcmp(value, "else") == 0)
-    tok = fzl_mktoken(FZL_TOKTYPE_ELSE, line, pos, value, size);
+    tok = fzl_mktoken(FZL_TOKTYPE_ELSE, l.line, l.col, value, size, l.filename);
  else if (strcmp(value, "true") == 0 || strcmp(value, "false") == 0)
-    tok = fzl_mktoken(FZL_TOKTYPE_BOOL_LITERAL, line, pos, value, size);
+    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 ||
@@ -89,9 +98,9 @@ fzl_token_t *parse_name(fzl_reader_t *reader)
           strcmp(value, "i64") == 0 || strcmp(value, "u8") == 0 ||
           strcmp(value, "u16") == 0 || strcmp(value, "u32") == 0 ||
           strcmp(value, "u64") == 0)
-    tok = fzl_mktoken(FZL_TOKTYPE_TYPE, line, pos, value, size);
+    tok = fzl_mktoken(FZL_TOKTYPE_TYPE, l.line, l.col, value, size, l.filename);
  else
-    tok = fzl_mktoken(FZL_TOKTYPE_NAME, line, pos, value, size);
+    tok = fzl_mktoken(FZL_TOKTYPE_NAME, l.line, l.col, value, size, l.filename);
  free(value);

  return tok;
@@ -120,26 +129,33 @@ fzl_token_t *parse_string_literal(fzl_reader_t *reader)
  } while (reader->source[lpos] != open_symbol && lpos < reader->size);
  size++;

+  fzl_file_loc 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;
+  }
+
  if (close_symbol != open_symbol)
  {
-    snprintf(last_err, sizeof(last_err), "unterminated string at %ld:%ld",
-             reader->line_n, reader->position - reader->line_start);
+    snprintf(last_err, sizeof(last_err), "'%s': unterminated string at %ld:%ld",
+             l.filename, l.line, l.col);
    return NULL;
  }

  if (size == 2)
  {
    fzl_token_t *tok =
-        fzl_mktoken(FZL_TOKTYPE_STR_LITERAL, reader->line_n,
-                    reader->position - reader->line_start, "", 0);
+        fzl_mktoken(FZL_TOKTYPE_STR_LITERAL, l.line, l.col, "", 0, l.filename);
    move(reader, 2);
    return tok;
  }

  char *value = malloc(size - 2);
  memcpy(value, reader->source + reader->position + 1, size - 2);
-  fzl_token_t *tok = fzl_mktoken(FZL_TOKTYPE_STR_LITERAL, reader->line_n,
-                                 lpos - reader->line_start, value, size - 2);
+  fzl_token_t *tok = fzl_mktoken(FZL_TOKTYPE_STR_LITERAL, l.line, l.col, value,
+                                 size - 2, l.filename);
  free(value);
  move(reader, size);

@@ -166,8 +182,16 @@ fzl_token_t *parse_number(fzl_reader_t *reader)
  memcpy(value, reader->source + reader->position, size);
  value[size] = '\0';

-  fzl_token_t *tok = fzl_mktoken(FZL_TOKTYPE_NUM_LITERAL, reader->line_n,
-                                 lpos - reader->line_start, value, size);
+  fzl_file_loc 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;
+  }
+
+  fzl_token_t *tok = fzl_mktoken(FZL_TOKTYPE_NUM_LITERAL, l.line, l.col, value,
+                                 size, l.filename);
  free(value);

  if (!tok)
@@ -180,15 +204,43 @@ 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);
-  return fzl_mktoken(type, reader->line_n, p - reader->line_start, NULL, 0);
+  fzl_file_loc 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;
+  }
+
+  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);
-  return fzl_mktoken(type, reader->line_n, p - reader->line_start, NULL, 0);
+  fzl_file_loc 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;
+  }
+
+  move(reader, 2);
+  return fzl_mktoken(type, l.line, l.col, "", 0, l.filename);
+}
+
+// Skip symbols until '\n' or EOF
+void skip_comment(fzl_reader_t *reader)
+{
+  move(reader, 2);
+
+  while (reader->position < reader->size)
+  {
+    if (reader->source[reader->position++] == '\n')
+      break;
+  }
 }

 int fzl_read(fzl_reader_t *reader)
@@ -210,6 +262,11 @@ int fzl_read(fzl_reader_t *reader)

    if (curr == '\'' || curr == '"')
      token = parse_string_literal(reader);
+    else if (curr == '/' && reader->source[p + 1] == '/')
+    {
+      skip_comment(reader);
+      continue;
+    }
    else if (curr == '=' && reader->source[p + 1] == '=')
      token = add_double(reader, FZL_TOKTYPE_EQEQ);
    else if (curr == '>' && reader->source[p + 1] == '=')
@@ -240,6 +297,8 @@ int fzl_read(fzl_reader_t *reader)
      token = add_single(reader, FZL_TOKTYPE_RPAREN);
    else if (curr == ',')
      token = add_single(reader, FZL_TOKTYPE_COMMA);
+    else if (curr == '.')
+      token = add_single(reader, FZL_TOKTYPE_DOT);
    else if (curr == '*')
      token = add_single(reader, FZL_TOKTYPE_STAR);
    else if (curr == '/')
@@ -254,27 +313,47 @@ 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')
      token = parse_number(reader);
    else
    {
-      sprintf(last_err, "undefined token '%c' at %ld:%ld", curr, reader->line_n,
-              p - reader->line_start);
+      fzl_file_loc l;
+      bool ok = fzl_linked_getpos(reader->linked, p, &l);
+      if (!ok)
+      {
+        snprintf(last_err, sizeof(last_err), "failed to locate line:col");
+        return -1;
+      }
+
+      sprintf(last_err, "'%s': undefined token '%c' at %ld:%ld", l.filename,
+              curr, l.line, l.col);
      return -1;
    }

    if (!token)
    {
      if (!last_err[0])
-        sprintf(last_err, "cannot parse token at %ld:%ld", reader->line_n,
-                p - reader->line_start);
+      {
+        fzl_file_loc l;
+        bool ok = fzl_linked_getpos(reader->linked, p, &l);
+        if (!ok)
+        {
+          snprintf(last_err, sizeof(last_err), "failed to locate line:col");
+          return -1;
+        }
+
+        sprintf(last_err, "'%s': cannot parse token at %ld:%ld", l.filename,
+                l.line, l.col);
+      }
+
      return -1;
    }

    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;
@@ -4,19 +4,25 @@
 #include <string.h>

 fzl_token_t *fzl_mktoken(const fzl_toktype_t type, size_t line, size_t col,
-                         void *value, size_t value_len)
+                         void *value, size_t value_len, char *filename)
 {
-  char *valholder = malloc(value_len + 1);
+  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;

  return token;
 }
@@ -5,6 +5,7 @@
 #include <compiler/fzl_token.h>
 #include <compiler/fzl_walker.h>
 #include <compiler/utils/fzl_const_pool.h>
+#include <compiler/utils/fzl_ctable.h>
 #include <compiler/utils/fzl_symtable.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -13,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)
@@ -53,6 +55,8 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
  }

  walker->ctx           = NULL;
+  walker->classes_count = 0;
+  memset(walker->classes, 0, sizeof(walker->classes));

  return walker;
 }
@@ -60,8 +64,11 @@ 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;
+
  if (strcmp((char *)tok->value, "i8") == 0)
    return FZL_TYPE_INT8;
  if (strcmp((char *)tok->value, "i16") == 0)
@@ -95,14 +102,53 @@ 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;

  return t1 >= FZL_TYPE_INT8 && t2 >= FZL_TYPE_INT8;
 }

+// Add one layer of ctx
+fzl_walk_ctx_t *nest_ctx(fzl_walker_t *walker, fzl_walk_ctx_type_t type)
+{
+  if (!walker)
+    return NULL;
+
+  fzl_walk_ctx_t *newctx = malloc(sizeof(fzl_walk_ctx_t));
+  if (!newctx)
+    return NULL;
+
+  newctx->type   = type;
+  newctx->parent = walker->ctx;
+  walker->ctx    = newctx;
+
+  return walker->ctx;
+}
+
+// Go outside current ctx and then clean it
+fzl_walk_ctx_t *fin_ctx(fzl_walker_t *walker)
+{
+  if (!walker)
+    return NULL;
+
+  fzl_walk_ctx_t *curr = walker->ctx;
+  walker->ctx          = walker->ctx->parent;
+
+  free(curr);
+  return walker->ctx;
+}
+
 // Add const to consts table
 size_t add_const(fzl_walker_t *walker, fzl_const_t c)
 {
@@ -154,6 +200,168 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
  {
    switch (node->type)
    {
+      case FZL_NODETYPE_CLASS:
+      {
+        fzl_walk_ctx_t *newctx = nest_ctx(walker, FZL_WALK_CTX_TYPE_CLASS);
+        if (!newctx)
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to nest context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        newctx->fn              = node;
+        newctx->initial_env_lvl = walker->sym_top;
+
+        walker->classes[walker->classes_count] =
+            fzl_mkctable(node->class.name->value);
+        fzl_ctable_t *class = walker->classes[walker->classes_count++];
+        class->name         = node->class.name->value;
+
+        for (size_t i = 0; i < node->class.fields_count; i++)
+        {
+          if (class->fields_remainder <= class->fields_count)
+          {
+            class->fields_remainder *= 2;
+            class->fields =
+                realloc(class->fields,
+                        class->fields_remainder * sizeof(fzl_ctable_field_t));
+          }
+
+          class->fields[class->fields_count] = (fzl_ctable_field_t){
+              .name       = node->class.fields[i]->var.identifier->token->value,
+              .type       = tok_to_type(node->class.fields[i]->var.type),
+              .slot_index = class->fields_count++};
+        }
+
+        for (size_t i = 0; i < node->class.methods_count; i++)
+        {
+          fzl_node_t *fn = node->class.methods[i];
+
+          size_t classname_len = strlen(class->name);
+          size_t fnname_len    = strlen(fn->fn.name->value);
+          char *method_name    = malloc(classname_len + fnname_len + 2);
+
+          strcpy(method_name, class->name);
+          method_name[classname_len] = '_';
+          strcpy((method_name + classname_len + 1), fn->fn.name->value);
+          method_name[classname_len + fnname_len + 1] = 0;
+
+          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)
+            return fnres;
+        }
+
+        if (!fin_ctx(walker))
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to clean context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
+        break;
+      }
+
+      case FZL_NODETYPE_CONSTRUCT:
+      {
+        fzl_node_t *classname = node->construct.name;
+        fzl_ctable_t *ct      = NULL;
+        for (size_t i = 0; i < walker->classes_count; i++)
+        {
+          if (strcmp((char *)classname->token->value,
+                     walker->classes[i]->name) == 0)
+          {
+            ct = walker->classes[i];
+            break;
+          }
+        }
+        if (!ct)
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': class '%s' not found (at %ld:%ld)",
+                   classname->token->filename, (char *)classname->token->value,
+                   classname->token->ln, classname->token->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        push_op(walker, FZL_OPCODE_ALLOC_OBJECT);
+        push_word(walker, ct->fields_count);
+
+        current_res = (fzl_walk_res_t){
+            .type = FZL_TYPE_OBJECT, .error = false, .classname = ct->name};
+        break;
+      }
+
+      case FZL_NODETYPE_FIELD:
+      {
+        fzl_walk_res_t parent_res = walk(walker, node->memb.parent);
+        if (parent_res.error)
+          return parent_res;
+
+        if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
+        {
+          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(parent_res.classname, walker->classes[i]->name) == 0)
+          {
+            ct = walker->classes[i];
+            break;
+          }
+        }
+
+        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);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        fzl_token_t *ftok = node->memb.field->token;
+        fzl_ctable_field_t ctf;
+        bool field_exists = false;
+        for (size_t i = 0; i < ct->fields_count; i++)
+        {
+          if (strcmp(ftok->value, ct->fields[i].name) == 0)
+          {
+            field_exists = true;
+            ctf          = ct->fields[i];
+            break;
+          }
+        }
+
+        if (!field_exists)
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': cannot find field '%s' in class '%s' at %ld:%ld",
+                   ftok->filename, (char *)ftok->value, parent_res.classname,
+                   ftok->ln, ftok->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        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 = parent_res.classname};
+        break;
+      }
+
      case FZL_NODETYPE_FUNCTION:
      {
        push_op(walker, FZL_OPCODE_JMP);
@@ -164,26 +372,53 @@ 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)
-            snprintf(wlast_err, sizeof(wlast_err),
-                     "cannot define already declared name '%s' at %ld:%ld",
-                     (char *)node->fn.name->value, node->token->ln,
-                     node->token->cn);
+            snprintf(
+                wlast_err, sizeof(wlast_err),
+                "'%s': cannot define already declared name '%s' at %ld:%ld",
+                node->token->filename, (char *)node->fn.name->value,
+                node->token->ln, node->token->cn);
          else
-            snprintf(wlast_err, sizeof(wlast_err), "failed to store name '%s'",
+            snprintf(wlast_err, sizeof(wlast_err),
+                     "'%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
-        size_t lvl                      = walker->sym_top;
+        ssize_t lvl                     = walker->sym_top;
        walker->syms[walker->sym_top++] = fzl_mksymt();
-        walker->ctx                     = malloc(sizeof(fzl_walk_ctx_t));
-        walker->ctx->fn                 = node;
-        walker->ctx->initial_env_lvl    = lvl;
+
+        fzl_walk_ctx_t *newctx = nest_ctx(walker, FZL_WALK_CTX_TYPE_FN);
+        if (!newctx)
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to nest context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        newctx->type            = FZL_WALK_CTX_TYPE_FN;
+        newctx->fn              = node;
+        newctx->initial_env_lvl = lvl;

        push_op(walker, FZL_OPCODE_MK_ENVTABLE);

@@ -203,48 +438,74 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        // near future

        push_op(walker, FZL_OPCODE_RM_ENVTABLE);
+        push_op(walker, FZL_OPCODE_RET);
        walker->ops[skip_ip] = walker->op_count;

-        walker->ctx = NULL; // NOTE: think about nested function defs (not now)
+        if (!fin_ctx(walker))
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to clean context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
        for (ssize_t i = walker->sym_top - 1; i >= lvl; i--)
          fzl_freesymt(walker->syms[--walker->sym_top]);

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

      case FZL_NODETYPE_RETURN:
      {
-        if (!walker->ctx)
+        if (!walker->ctx || walker->ctx->type != FZL_WALK_CTX_TYPE_FN)
        {
-          snprintf(wlast_err, sizeof(wlast_err),
-                   "return cannot be used outside of functions");
+          snprintf(
+              wlast_err, sizeof(wlast_err),
+              "'%s': return cannot be used outside of functions (at %ld:%ld)",
+              node->token->filename, node->token->ln, node->token->cn);
          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,
-                             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(wlast_err, sizeof(wlast_err),
-                     "incompatible types between return and function type at "
+            snprintf(
+                wlast_err, sizeof(wlast_err),
+                "'%s': incompatible types between return and function type at "
                "%ld:%ld",
-                     node->token->ln, node->token->cn);
+                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 = 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;
      }
@@ -275,14 +536,55 @@ 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),
-                   "incompatible types at %ld:%ld", node->token->ln,
-                   node->token->cn);
+                   "'%s': incompatible types at %ld:%ld", node->token->filename,
+                   node->token->ln, node->token->cn);
          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:
@@ -306,8 +608,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;
      }

@@ -322,11 +625,12 @@ 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),
-                   "incompatible types at %ld:%ld", node->token->ln,
-                   node->token->cn);
+                   "'%s': incompatible types at %ld:%ld", node->token->filename,
+                   node->token->ln, node->token->cn);
          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
        }

@@ -335,7 +639,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;
      }

@@ -400,9 +704,9 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        if (!exists)
        {
          snprintf(wlast_err, sizeof(wlast_err),
-                   "cannot find symbol '%s' at %ld:%ld",
-                   (char *)node->token->value, node->token->ln,
-                   node->token->cn);
+                   "'%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};
        }

@@ -410,7 +714,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        push_word(walker, n);
        push_op(walker, FZL_OPCODE_LOOKUP_ENV);

-        current_res = (fzl_walk_res_t){.type = sym.type, .error = false};
+        current_res = (fzl_walk_res_t){
+            .type = sym.type, .error = false, .classname = sym.classname};
        break;
      }

@@ -429,6 +734,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        break;

      case FZL_NODETYPE_CALL:
+        if (strcmp(node->token->value, "printline") == 0)
+        {
          if (node->call.args_count > 0)
          {
            for (size_t i = 0; i < node->call.args_count; i++)
@@ -439,21 +746,55 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
            }
          }

-        if (strcmp(node->token->value, "printline") == 0)
-        {
          push_op(walker, FZL_OPCODE_CALL_BUILTIN);
          push_word(walker, FZL_BUILTIN_PRINTLINE);
          if (node->call.args_count < 1)
          {
            snprintf(wlast_err, sizeof(wlast_err),
-                     "'printline' call with zero arguments at %ld:%ld",
-                     node->token->ln, node->token->cn);
+                     "'%s': 'printline' 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 (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)
+          {
+            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;
+              }
+            }
+
            fzl_sym_t res;
            bool found = false;
            for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
@@ -464,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};
            }

@@ -479,7 +821,92 @@ 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_walk_res_t parent_res = walk(walker, parent_node);
+            if (parent_res.error)
+              return parent_res;
+
+            if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
+            {
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "'%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};
+            }
+
+            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': 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};
+            }
+
+            size_t classlen  = strlen(classname);
+            size_t fnlen     = strlen(method_node->token->value);
+            char *methodname = malloc(classlen + fnlen + 2);
+            strcpy(methodname, classname);
+            strcpy((methodname + classlen + 1),
+                   node->call.callee->token->value);
+            methodname[classlen]             = '_';
+            methodname[classlen + fnlen + 1] = 0;
+
+            fzl_sym_t fn_sym;
+            bool found_method = false;
+            for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
+              if ((found_method =
+                       fzl_symt_get(walker->syms[i], methodname, &fn_sym)))
+                break;
+
+            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);
+
+            if (node->call.args_count > 0)
+            {
+              for (size_t i = 0; i < node->call.args_count; i++)
+              {
+                fzl_walk_res_t res = walk(walker, node->call.args[i]);
+                if (res.error)
+                  return res;
+              }
+            }
+
+            push_op(walker, FZL_OPCODE_CALL);
+            push_word(walker, fn_sym.ip);
+
+            current_res = (fzl_walk_res_t){.type      = fn_sym.type,
+                                           .error     = false,
+                                           .classname = fn_sym.classname};
+          }
        }
        break;

@@ -513,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:
@@ -534,18 +969,19 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        {
          fzl_token_t *ltok = node->binary_op.left->token;
          snprintf(wlast_err, sizeof(wlast_err),
-                   "left operand at %ld:%ld is not compatible to integer types",
-                   ltok->ln, ltok->cn);
+                   "'%s': left operand at %ld:%ld is not compatible to integer "
+                   "types",
+                   ltok->filename, ltok->ln, ltok->cn);
          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
        }

        if (rres.type < FZL_TYPE_INT8)
        {
          fzl_token_t *rtok = node->binary_op.right->token;
-          snprintf(
-              wlast_err, sizeof(wlast_err),
-              "right operand at %ld:%ld is not compatible to integer types",
-              rtok->ln, rtok->cn);
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': right operand at %ld:%ld is not compatible to "
+                   "integer types",
+                   rtok->filename, rtok->ln, rtok->cn);
          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
        }

@@ -586,8 +1022,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        {
          fzl_token_t *tok = node->unary_op.operand->token;
          snprintf(wlast_err, sizeof(wlast_err),
-                   "incompatible with unary operator type at %ld:%ld", tok->ln,
-                   tok->cn);
+                   "'%s': incompatible with unary operator type at %ld:%ld",
+                   tok->filename, tok->ln, tok->cn);
          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
        }

@@ -598,9 +1034,33 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)

      case FZL_NODETYPE_DECLARATION:
      {
+        fzl_ctable_t *ct = NULL;
+        for (size_t i = 0; i < walker->classes_count; i++)
+        {
+          if (strcmp(node->var.type->value, walker->classes[i]->name) == 0)
+          {
+            ct = walker->classes[i];
+            break;
+          }
+        }
+
        fzl_symtable_res_t res = fzl_symt_put(
            walker->syms[walker->sym_top - 1],
-            node->var.identifier->token->value, tok_to_type(node->var.type), 0);
+            node->var.identifier->token->value,
+            ct != NULL ? FZL_TYPE_OBJECT : tok_to_type(node->var.type), 0);
+
+        if (ct)
+          fzl_symt_setobjclass(walker->syms[walker->sym_top - 1],
+                               node->var.identifier->token->value, ct->name);
+
+        if (res != FZL_SYMTABLE_RESULT_OK)
+        {
+          fzl_token_t *tok = node->var.identifier->token;
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': cannot store '%s' at %ld:%ld", tok->filename,
+                   (char *)tok->value, tok->ln, tok->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }

        fzl_token_t *id_tok = node->var.identifier->token;
        size_t const_n      = add_const(
@@ -615,7 +1075,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;
      }

@@ -625,11 +1087,20 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        if (rres.error)
          return rres;

+        fzl_walk_ctx_t *newctx = nest_ctx(walker, FZL_WALK_CTX_TYPE_ASSIGN);
+        if (!newctx)
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to nest context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
        if (node->binary_op.left->type == FZL_NODETYPE_DECLARATION)
        {
          fzl_walk_res_t lres = walk(walker, node->binary_op.left);
          if (lres.error)
            return lres;
+
+          push_op(walker, FZL_OPCODE_WRITE);
        }
        else if (node->binary_op.left->type == FZL_NODETYPE_IDENTIFIER)
        {
@@ -643,19 +1114,20 @@ 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),
-                     "name '%s' is not exists at %ld:%ld", (char *)tok->value,
-                     tok->ln, tok->cn);
+                     "'%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),
-                     "R-Value is not compatible with L-Value at %ld:%ld",
-                     tok->ln, tok->cn);
+                     "'%s': R-Value is not compatible with L-Value at %ld:%ld",
+                     tok->filename, tok->ln, tok->cn);
            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
          }

@@ -666,10 +1138,67 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
                                        node->binary_op.left->token->value_sz});
          push_op(walker, FZL_OPCODE_LOADCONST);
          push_word(walker, const_n);
+          push_op(walker, FZL_OPCODE_WRITE);
+        }
+        else if (node->binary_op.left->type == FZL_NODETYPE_FIELD)
+        {
+          fzl_node_t *field_node = node->binary_op.left;
+          fzl_walk_res_t obj_res = walk(walker, field_node->memb.parent);
+          if (obj_res.error)
+            return obj_res;
+
+          fzl_ctable_t *ct = NULL;
+          for (size_t i = 0; i < walker->classes_count; i++)
+          {
+            if (strcmp(obj_res.classname, walker->classes[i]->name) == 0)
+            {
+              ct = walker->classes[i];
+              break;
+            }
          }

-        push_op(walker, FZL_OPCODE_WRITE);
-        current_res = (fzl_walk_res_t){.type = rres.type, .error = false};
+          if (!ct)
+          {
+            snprintf(wlast_err, sizeof(wlast_err),
+                     "'%s': cannot find class '%s' at %ld:%ld",
+                     field_node->token->filename, obj_res.classname,
+                     field_node->token->ln, field_node->token->cn);
+            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+          }
+
+          fzl_ctable_field_t *ctf = NULL;
+          for (size_t i = 0; i < ct->fields_count; i++)
+          {
+            if (strcmp(field_node->memb.field->token->value,
+                       ct->fields[i].name) == 0)
+            {
+              ctf = &ct->fields[i];
+              break;
+            }
+          }
+
+          if (!ctf)
+          {
+            fzl_node_t *fn = field_node->memb.field;
+            snprintf(wlast_err, sizeof(wlast_err),
+                     "'%s': class '%s' has no field '%s' at %ld:%ld",
+                     fn->token->filename, obj_res.classname,
+                     (char *)fn->token->value, fn->token->ln, fn->token->cn);
+            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+          }
+
+          push_op(walker, FZL_OPCODE_SET_FIELD);
+          push_word(walker, ctf->slot_index);
+        }
+
+        if (!fin_ctx(walker))
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to clean context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        current_res = (fzl_walk_res_t){
+            .type = rres.type, .error = false, .classname = rres.classname};
        break;
      }
    }
@@ -689,10 +1218,14 @@ int fzl_walk(fzl_walker_t *walker)
    return -1;
  }

+  nest_ctx(walker, FZL_WALK_CTX_TYPE_GLOBAL);
+
  push_op(walker, FZL_OPCODE_MK_ENVTABLE);
  fzl_walk_res_t result = walk(walker, walker->root);
  push_op(walker, FZL_OPCODE_RM_ENVTABLE);

+  fin_ctx(walker);
+
  if (result.error && !wlast_err[0])
    snprintf(wlast_err, sizeof(wlast_err), "%s", result.error_msg);

@@ -716,5 +1249,8 @@ void fzl_freewalker(fzl_walker_t *walker)
  while (walker->sym_top > 0)
    fzl_freesymt(walker->syms[--walker->sym_top]);

+  for (size_t i = 0; i < walker->classes_count; i++)
+    fzl_freectable(walker->classes[i]);
+
  free(walker);
 }
@@ -1,147 +1,82 @@
+#include <common/fzl_colors.h>
 #include <compiler/fzl_debug.h>
 #include <compiler/fzl_parser.h>
 #include <compiler/fzl_reader.h>
 #include <compiler/fzl_walker.h>
 #include <compiler/fzl_writer.h>
+#include <compiler/utils/fzl_linked.h>
+#include <compiler/utils/fzl_options.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

-// Build arguments setup descriptor
-typedef struct
-{
-  char *filepath;
-  char *outpath;
-  bool verbose;
-  bool help;
-} build_args_t;
-
-// Print command usage hint
-void print_usage()
-{
-  printf("Usage: fzc [flags] <file path>\n");
-  printf("Flags:\n");
-  printf("\t-v\t--verbose\tdisplay debug information\n");
-  printf("\t-h\t--help\t\tprint usage hint (which you're looking at)\n");
-}
-
-// Read the arguments and build `build_args_t` struct
-build_args_t *getargs(int argc, char **argv)
-{
-  build_args_t *args = malloc(sizeof(build_args_t));
-  if (!args)
-    return NULL;
-
-  args->filepath = NULL;
-  args->outpath = NULL;
-  args->verbose = false;
-  args->help = false;
-
-  size_t args_total = 0;
-  if (argc > 2)
-  {
-    for (int i = 1; i < argc; i++)
-    {
-      if (argv[i][0] != '-')
-        continue;
-
-      args_total++;
-
-      if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
-      {
-        args->help = true;
-      }
-      else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0)
-      {
-        args->verbose = true;
-      }
-      else if (strcmp(argv[i], "-o") == 0 || strcmp(argv[i], "--out") == 0)
-      {
-        if (!argv[i + 1] || argv[i + 1][0] == '-')
-        {
-          printf("Error: file path is not specified.\n");
-          return NULL;
-        }
-        args->outpath = argv[++i];
-      }
-      else
-      {
-        printf("Error: unknown argument '%s'\n", argv[i]);
-        return NULL;
-      }
-    }
-  }
-
-  if (argc - 1 - args_total < 1)
-  {
-    printf("Error: source code file is not specified.\n");
-    print_usage();
-    return NULL;
-  }
-
-  if (argv[argc - 1][0] == '-')
-  {
-    printf("Error: last argument MUST be a path to file.\n");
-    printf("Write 'fzc --help' to read help\n");
-    return NULL;
-  }
-
-  args->filepath = argv[argc - 1];
-  return args;
-}
-
 int main(int argc, char **argv)
 {
-  build_args_t *args = getargs(argc, argv);
-  if (args == NULL)
+  fzl_options_t *opts = fzl_mkoptions(argc, argv);
+  if (!opts)
+  {
+    fzl_freeoptions(opts);
    return -1;
-  else if (args->help)
+  }
+  else if (!opts->should_continue)
+  {
+    fzl_freeoptions(opts);
    return 0;
+  }

-  if (args->verbose)
-    printf("> analyze\n-> reading file...");
+  if (opts->verbose)
+    printf("%s> analyze\n-> reading file...%s", FZL_CDEBUG, FZL_CRST);

-  char *source;
-  FILE *fd = fopen(args->filepath, "r");
-  if (!fd)
+  fzl_linked_t *linked = fzl_mklinked();
+  if (!linked)
  {
-    printf("Error: failed to open file '%s'\n", args->filepath);
+    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;
  }

-  fseek(fd, 0L, SEEK_END);
-  size_t fsz = ftell(fd);
-  rewind(fd);
-
-  source = malloc(fsz + 1);
-  fread(source, fsz, 1, fd);
-  fclose(fd);
-  source[fsz] = '\0';
-
-  if (args->verbose)
+  bool read_result =
+      fzl_linked_add_files(linked, opts->files, opts->files_count);
+  if (!read_result)
  {
-    printf("ok!\n");
-    printf("--> Red %ld bytes\n", fsz);
-    printf("-> tokenizing...");
+    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;
  }

-  fzl_reader_t *rd = fzl_mkreader(source);
+  if (opts->verbose)
+  {
+    printf("%sok%s!\n", FZL_COK, FZL_CRST);
+    printf("%s--> Red %ld bytes%s\n", FZL_CDEBUG, linked->total_sz, FZL_CRST);
+    printf("%s-> tokenizing...%s", FZL_CDEBUG, FZL_CRST);
+  }
+
+  fzl_reader_t *rd = fzl_mkreader(linked);
  int result       = fzl_read(rd);
  if (result != 0)
  {
-    printf("error: %s\n", fzl_reader_geterror());
+    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_reader_geterror());
+    fzl_freeoptions(opts);
+    fzl_freelinked(linked);
+    fzl_freereader(rd);
    return -1;
  }

-  if (args->verbose)
-    printf("ok!\n");
+  if (opts->verbose)
+    printf("%sok%s!\n", FZL_COK, FZL_CRST);

  fzl_reader_ll_t *entry = rd->first;

-  if (args->verbose)
+  if (opts->verbose)
  {
-    printf("--> structure: ");
+    printf("%s--> structure: %s", FZL_CDEBUG, FZL_CRST);
    while (entry)
    {
      if (entry->token)
@@ -157,42 +92,51 @@ int main(int argc, char **argv)
    }

    printf("\n");
-    printf("-> parsing...");
+    printf("%s-> parsing...%s", FZL_CDEBUG, FZL_CRST);
  }

  fzl_parser_t *parser = fzl_mkparser(rd->first);
  result               = fzl_parse(parser);
  if (result != 0)
  {
-    printf("Error: %s\n", fzl_parser_geterror());
+    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;
  }

-  if (args->verbose)
+  if (opts->verbose)
  {
-    printf("ok!\n");
+    printf("%sok%s!\n", FZL_COK, FZL_CRST);
    fzl_debug_print_ast(parser->root);
-    printf("> building\n");
-    printf("-> walking AST...\n");
+    printf("%s> building%s\n", FZL_CDEBUG, FZL_CRST);
+    printf("%s-> walking AST...%s\n", FZL_CDEBUG, FZL_CRST);
  }

  fzl_walker_t *walker = fzl_mkwalker(parser->root);
  result               = fzl_walk(walker);
  if (result != 0)
  {
-    printf("Error: %s\n", fzl_walker_geterror());
+    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;
  }

-  if (args->verbose)
+  if (opts->verbose)
  {
-    printf("ok!\n");
+    printf("%sok%s!\n", FZL_COK, FZL_CRST);

-    printf("--> Constants table:\n");
+    printf("%s--> Constants table%s:\n", FZL_CDEBUG, FZL_CRST);
    for (size_t i = 0; i < walker->consts->size; i++)
      printf("---> %s\n", walker->consts->array[i].as.string.chars);

-    printf("--> Ops:\n");
+    printf("%s--> Ops%s:\n", FZL_CDEBUG, FZL_CRST);
    printf("---> ");
    for (size_t i = 0; i < walker->op_count; i++)
    {
@@ -202,40 +146,46 @@ int main(int argc, char **argv)
    }
    printf("\n");

-    printf("-> preparing final write\n");
+    printf("%s-> preparing final write%s\n", FZL_CDEBUG, FZL_CRST);
  }

  char outpath[256];
-  if (args->outpath)
-    strcpy(outpath, args->outpath);
+  if (opts->outname)
+    strcpy(outpath, opts->outname);
  else
    strcpy(outpath, "a.fzb");

-  if (args->verbose)
+  if (opts->verbose)
  {
-    printf("-> output file path is: %s\n", outpath);
-    printf("-> writing file...");
+    printf("%s-> output file path is%s: %s\n", FZL_CDEBUG, FZL_CRST, outpath);
+    printf("%s-> writing file...%s", FZL_CDEBUG, FZL_CRST);
  }

  fzl_writer_t *writer = fzl_mkwriter(outpath);
  result               = fzl_write(writer, walker);
  if (result != 0)
  {
-    printf("Error: %s\n", fzl_writer_geterror());
+    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;
  }

-  if (args->verbose)
-    printf("ok!\n");
+  if (opts->verbose)
+    printf("%sok%s!\n", FZL_COK, FZL_CRST);

-  free(source);
-  free(args);
+  fzl_freeoptions(opts);
+  fzl_freelinked(linked);
  fzl_freereader(rd);
  fzl_freeast(parser->root);
  fzl_freeparser(parser);
  fzl_freewalker(walker);
  fzl_freewriter(writer);

-  printf("done.\n");
+  printf("%sCompiled successfully%s.\n", FZL_COK, FZL_CRST);
  return 0;
 }
@@ -24,7 +24,7 @@ bool fzl_consts_equal(fzl_const_t a, fzl_const_t b)
  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;
  const uint8_t *data = NULL;
@@ -58,20 +58,20 @@ fzl_const_hash_pool_t *fzl_mkconstpool()
  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;
  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;

@@ -0,0 +1,29 @@
+#include <compiler/utils/fzl_ctable.h>
+#include <stdlib.h>
+#include <string.h>
+
+fzl_ctable_t *fzl_mkctable(char *name)
+{
+  fzl_ctable_t *ctable = malloc(sizeof(fzl_ctable_t));
+  if (!ctable)
+    return NULL;
+
+  memset(ctable, 0, sizeof(fzl_ctable_t));
+  ctable->name             = name;
+  ctable->fields_remainder = 2;
+  ctable->fields =
+      malloc(ctable->fields_remainder * sizeof(fzl_ctable_field_t));
+
+  return ctable;
+}
+
+void fzl_freectable(fzl_ctable_t *ct)
+{
+  if (!ct)
+    return;
+
+  if (ct->fields)
+    free(ct->fields);
+
+  free(ct);
+}
@@ -0,0 +1,160 @@
+#include <compiler/utils/fzl_linked.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char llast_err[256];
+
+fzl_linked_t *fzl_mklinked()
+{
+  fzl_linked_t *l = malloc(sizeof(fzl_linked_t));
+  if (!l)
+  {
+    snprintf(llast_err, sizeof(llast_err), "potato PC...");
+    return NULL;
+  }
+
+  l->entries       = NULL;
+  l->entries_count = 0;
+  l->source        = NULL;
+  l->total_sz      = 0;
+
+  return l;
+}
+
+bool fzl_linked_add_files(fzl_linked_t *l, char **files, size_t files_count)
+{
+  if (!l)
+    return false;
+
+  size_t eremainder           = 2;
+  size_t ecount               = 0;
+  fzl_linked_entry_t *entries = malloc(eremainder * sizeof(fzl_linked_entry_t));
+
+  size_t current_start = 0;
+  for (size_t i = 0; i < files_count; i++)
+  {
+    char *source;
+    FILE *fd = fopen(files[i], "r");
+    if (!fd)
+    {
+      snprintf(llast_err, sizeof(llast_err), "failed to open file '%s'\n",
+               files[i]);
+      free(entries);
+      return false;
+    }
+
+    fseek(fd, 0L, SEEK_END);
+    size_t file_sz = ftell(fd);
+    rewind(fd);
+
+    source = malloc(file_sz + 1);
+    fread(source, file_sz, 1, fd);
+    fclose(fd);
+    source[file_sz] = 0;
+
+    if (eremainder <= ecount)
+    {
+      eremainder *= 2;
+      entries = realloc(entries, eremainder * sizeof(fzl_linked_entry_t));
+      if (!entries)
+      {
+        snprintf(llast_err, sizeof(llast_err), "potato pc...");
+        free(source);
+        return NULL;
+      }
+    }
+    entries[ecount++] =
+        (fzl_linked_entry_t){.name  = files[i],
+                             .start = current_start,
+                             .end   = current_start + file_sz - 1};
+
+    if (!l->source)
+      l->source = malloc(file_sz + 1);
+    else
+      l->source = realloc(l->source, current_start + file_sz + 1);
+
+    if (!l->source)
+    {
+      snprintf(llast_err, sizeof(llast_err),
+               "failed to allocate space for source code holder");
+      free(entries);
+      free(source);
+      return NULL;
+    }
+
+    strcpy(l->source + current_start, source);
+    free(source);
+    current_start += file_sz;
+  }
+
+  l->source = realloc(l->source, current_start + 1);
+  if (!l->source)
+  {
+    snprintf(llast_err, sizeof(llast_err),
+             "not enough space for entire source\n");
+    free(entries);
+    return NULL;
+  }
+
+  l->source[current_start] = 0;
+
+  l->entries       = entries;
+  l->entries_count = ecount;
+  l->total_sz      = current_start;
+  return true;
+}
+
+char *fzl_linked_geterror() { return llast_err; }
+
+bool fzl_linked_getpos(fzl_linked_t *l, size_t pos, fzl_file_loc *res)
+{
+  if (!l)
+    return false;
+
+  bool found = false;
+  fzl_linked_entry_t e;
+  for (size_t i = 0; i < l->entries_count; i++)
+  {
+    e = l->entries[i];
+    if (pos >= e.start && pos <= e.end)
+    {
+      found = true;
+      break;
+    }
+  }
+
+  if (!found)
+    return NULL;
+
+  size_t line       = 1;
+  size_t line_start = e.start;
+  for (size_t p = e.start; p < pos; p++)
+  {
+    if (l->source[p] == '\n')
+    {
+      line++;
+      line_start = p + 1;
+    }
+  }
+
+  *res =
+      (fzl_file_loc){.filename = e.name, .line = line, .col = pos - line_start};
+  return true;
+}
+
+void fzl_freelinked(fzl_linked_t *linked)
+{
+  if (!linked)
+    return;
+
+  if (linked->source)
+    free(linked->source);
+
+  if (linked->entries)
+    free(linked->entries);
+
+  free(linked);
+}
@@ -0,0 +1,131 @@
+#include <common/fzl_colors.h>
+#include <compiler/utils/fzl_options.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+const char version[] = "FZL Compiler 1.0";
+
+void print_help()
+{
+  printf("Usage: fzc [flags] <sources...>\n");
+  printf("Available flags:\n");
+  printf("\t-h\t--help\t\tPrint help\n");
+  printf("\t-v\t--verbose\tDisplay compilation info (tokens, AST, consts "
+         "table, etc)\n");
+  printf("\t-V\t--version\tPrint compiler version\n");
+  printf("\t-o\t--out\t\tSet compiled file name\n");
+}
+
+fzl_options_t *fzl_mkoptions(int argc, char **argv)
+{
+  fzl_options_t *opts = malloc(sizeof(fzl_options_t));
+  if (!opts)
+  {
+    printf("%sBruh... Potato PC%s\n", FZL_CERROR, FZL_CRST);
+    return NULL;
+  }
+
+  memset(opts, 0, sizeof(fzl_options_t));
+
+  if (argc < 2)
+  {
+    print_help();
+    opts->should_continue = false;
+    return opts;
+  }
+
+  int i;
+  for (i = 1; i < argc; i++)
+  {
+    if (argv[i][0] != '-')
+      break;
+
+    if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
+    {
+      print_help();
+      opts->should_continue = false;
+      break;
+    }
+    else if (strcmp(argv[i], "-V") == 0 || strcmp(argv[i], "--version") == 0)
+    {
+      printf("%s\n", version);
+      opts->should_continue = false;
+      break;
+    }
+    else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0)
+    {
+      opts->verbose = true;
+    }
+    else if (strcmp(argv[i], "-o") == 0 || strcmp(argv[i], "--out") == 0)
+    {
+      if (i == argc - 1)
+      {
+        printf("%sError%s: missing out file name\n", FZL_CERROR, FZL_CRST);
+        free(opts);
+        return NULL;
+      }
+
+      char *filename = argv[++i];
+      opts->outname  = filename;
+    }
+    else
+    {
+      printf("%sError%s: undefined flag '%s'\n", FZL_CERROR, FZL_CRST, argv[i]);
+      free(opts);
+      return NULL;
+    }
+  }
+
+  size_t fremainder = 2;
+  size_t fcount     = 0;
+  char **files      = malloc(fremainder * sizeof(char *));
+
+  for (; i < argc; i++)
+  {
+    if (argv[i][0] == '-')
+    {
+      printf(
+          "%sWarning%s: unhandled flag '%s' (should be defined before sources "
+          "list)\n",
+          FZL_CWARNING, FZL_CRST, argv[i]);
+      continue;
+    }
+
+    if (fremainder <= fcount)
+    {
+      fremainder *= 2;
+      files = realloc(files, fremainder * sizeof(char *));
+    }
+
+    files[fcount++] = argv[i];
+  }
+
+  opts->files       = files;
+  opts->files_count = fcount;
+
+  if (i < argc - 1)
+  {
+    printf("%sError%s: flags should go before source files list.\n", FZL_CERROR,
+           FZL_CRST);
+    printf("Remain %d arguments are not handled.\n", argc - 1 - i);
+
+    free(files);
+    free(opts);
+    return NULL;
+  }
+
+  opts->should_continue = true;
+  return opts;
+}
+
+void fzl_freeoptions(fzl_options_t *options)
+{
+  if (!options)
+    return;
+
+  if (options->files)
+    free(options->files);
+
+  free(options);
+}
@@ -1,3 +1,4 @@
+#include <common/fzl_types.h>
 #include <compiler/utils/fzl_symtable.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -37,10 +38,31 @@ fzl_symtable_res_t fzl_symt_put(fzl_symtable_t *symt, char *name,
  }

  symt->symbols[symt->size++] =
-      (fzl_sym_t){.name = name, .type = type, .ip = ip};
+      (fzl_sym_t){.name = name, .type = type, .ip = ip, .classname = NULL};
  return FZL_SYMTABLE_RESULT_OK;
 }

+fzl_symtable_res_t fzl_symt_setobjclass(fzl_symtable_t *symt, char *name,
+                                        char *classname)
+{
+  if (!symt)
+    return FZL_SYMTABLE_RESULT_ERR;
+
+  for (size_t i = 0; i < symt->size; i++)
+  {
+    if (strcmp(symt->symbols[i].name, name) == 0)
+    {
+      if (symt->symbols[i].type != FZL_TYPE_OBJECT)
+        return FZL_SYMTABLE_RESULT_NOT_OBJECT;
+
+      symt->symbols[i].classname = classname;
+      return FZL_SYMTABLE_RESULT_OK;
+    }
+  }
+
+  return FZL_SYMTABLE_RESULT_ERR;
+}
+
 bool fzl_symt_get(fzl_symtable_t *symt, char *name, fzl_sym_t *res)
 {
  if (!symt)
@@ -1,4 +1,3 @@
-#include "vm/fzl_vm_env.h"
 #include <common/fzl_builtins.h>
 #include <common/fzl_opcodes.h>
 #include <common/fzl_types.h>
@@ -10,8 +9,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
-
-// NOTE: need to add optimized arithmetics in near future
+#include <vm/fzl_vm_env.h>
+#include <vm/fzl_vm_object.h>

 char last_err[256];

@@ -43,6 +42,7 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
  if (!fd)
  {
    snprintf(last_err, sizeof(last_err), "failed to open file '%s'", filepath);
+    free(vm);
    return NULL;
  }

@@ -51,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;
  }

@@ -61,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;
  }

@@ -90,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;
@@ -105,10 +112,167 @@ 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)
+  {
+    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(%s)", arg.as.b ? "true" : "false");
+    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)
@@ -124,6 +288,235 @@ 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];
+        fzl_vm_object_t *obj  = malloc(sizeof(fzl_vm_object_t));
+        obj->values           = malloc(values_count * sizeof(fzl_value_t));
+        obj->values_count     = values_count;
+
+        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;
+      }
+
+      case FZL_OPCODE_GET_FIELD:
+      {
+        if (vm->dtop < 1)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - expected value in data stack");
+          print_err_data(vm);
+          return -1;
+        }
+
+        uint64_t field_slot = vm->ops[++vm->ip];
+        fzl_value_t val     = vm->dstack[--vm->dtop];
+        if (val.type != FZL_TYPE_OBJECT)
+        {
+          snprintf(
+              last_err, sizeof(last_err),
+              "runtime error - cannot access field #%lu of non-object type",
+              field_slot);
+          print_err_data(vm);
+          return -1;
+        }
+
+        fzl_vm_object_t *obj = val.as.obj;
+        if (obj->values_count <= field_slot)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - cannot access field #%lu", field_slot);
+          print_err_data(vm);
+          return -1;
+        }
+
+        vm->dstack[vm->dtop++] = obj->values[field_slot];
+        break;
+      }
+
+      case FZL_OPCODE_SET_FIELD:
+      {
+        if (vm->dtop < 2)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - expected two values in data stack");
+          print_err_data(vm);
+          return -1;
+        }
+
+        uint64_t field_slot = vm->ops[++vm->ip];
+        fzl_value_t objval  = vm->dstack[--vm->dtop];
+        fzl_value_t wrval   = vm->dstack[--vm->dtop];
+        if (objval.type != FZL_TYPE_OBJECT)
+        {
+          snprintf(
+              last_err, sizeof(last_err),
+              "runtime error - cannot access field #%lu of non-object type",
+              field_slot);
+          print_err_data(vm);
+          return -1;
+        }
+
+        fzl_vm_object_t *obj = objval.as.obj;
+        if (obj->values_count <= field_slot)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - cannot access field #%lu", field_slot);
+          print_err_data(vm);
+          return -1;
+        }
+
+        obj->values[field_slot] = wrval;
+        break;
+      }
+
      case FZL_OPCODE_CALL:
      {
        uint64_t ip            = vm->ops[++vm->ip];
@@ -138,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;
        }

@@ -150,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;
        }

@@ -164,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;
        }

@@ -178,6 +574,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;
        }

@@ -192,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;
        }

@@ -206,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;
        }

@@ -220,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;
        }

@@ -234,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;
        }

@@ -247,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;
        }

@@ -257,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;
        }

@@ -279,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;
        }

@@ -293,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;
        }

@@ -307,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)
@@ -322,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;
          }
        }
@@ -360,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;
        }

@@ -392,14 +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;
        }
      }
@@ -411,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];
@@ -426,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];
@@ -439,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];
@@ -452,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];
@@ -465,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];
@@ -478,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];
@@ -498,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];
@@ -511,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];
@@ -537,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;
    }

@@ -553,6 +1011,9 @@ 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)
@@ -20,15 +20,51 @@ 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;
+
+      case FZL_OPCODE_GET_FIELD:
+        printf("GET_FIELD #%lu\n", vm->ops[++i]);
+        break;
+
+      case FZL_OPCODE_SET_FIELD:
+        printf("SET_FIELD #%lu\n", vm->ops[++i]);
+        break;
+
      case FZL_OPCODE_CALL:
      {
        size_t ip = vm->ops[++i];
-        printf("Call IP: %lu\n", ip);
+        printf("CALL IP: %lu\n", ip);
        break;
      }

      case FZL_OPCODE_RET:
-        printf("Return\n");
+        printf("RET\n");
        break;

      case FZL_OPCODE_LOADCONST:
@@ -77,7 +113,7 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
      case FZL_OPCODE_DIV:
      case FZL_OPCODE_POW:
      case FZL_OPCODE_MOD:
-        printf("Math opcode\n");
+        printf("MATH\n");
        break;

      case FZL_OPCODE_AND:
@@ -129,7 +165,7 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
        break;

      default:
-        printf("<Unknown>\n");
+        printf("<UNKNOWN>\n");
    }
  }
 }
@@ -1,3 +1,4 @@
+#include "vm/fzl_vm_object.h"
 #include <common/fzl_types.h>
 #include <common/fzl_value.h>
 #include <stdbool.h>
@@ -6,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));
@@ -15,6 +14,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 +100,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);
 }
@@ -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
samsonium	ce13d24985	upd: optimize gdbinit script	2026-10-17 20:21:08 +03:00
samsonium	b48c196509	upd: new test in borrow-move example	2026-10-17 20:20:54 +03:00
samsonium	f1e97b94a4	fix: fix toke->value assign on name-not-found error	2026-10-17 20:20:10 +03:00
samsonium	645120eda6	feat: implement objects moving and borrowing	2026-10-17 19:24:03 +03:00
samsonium	2d307d9d42	Merge pull request 'feat: implement vm' (#1 ) from vm into master Reviewed-on: #1	2026-10-16 15:31:49 +00:00
samsonium	c643f200a1	upd: update READMEs	2026-10-16 18:31:19 +03:00
samsonium	4e7d09cfa9	fix: add objects cleanup after execution	2026-10-16 18:31:10 +03:00
samsonium	bc5d887ec4	feat: implement objects and classes	2026-10-16 18:11:28 +03:00
samsonium	683dd08181	wip: working on classes	2026-10-15 21:41:45 +03:00
samsonium	69b2253c34	feat: enhance compiler - Add comments and test for it - Add semicolon as required end of some expressions - Add new arguments parser - Add multi-file compilation - Add colors in output	2026-10-15 17:20:43 +03:00
samsonium	1035b9193c	feat: add comments	2026-10-15 15:52:47 +03:00