fix: sanitizer checks fix (iteration 3 - final)

- Add token check before parsing statement or program
- Fix program freeing

.clang-format

@@ -5,3 +5,5 @@ BreakBeforeBraces: Allman
 IndentWidth: 2
 TabWidth: 2
 UseTab: Never
+AlignConsecutiveAssignments: Consecutive
+IndentCaseLabels: True

.gdbinit

@@ -0,0 +1,15 @@
+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
+

.gitignore

@@ -8,8 +8,10 @@
 
 # Files
 !/.clang-format
+!/.gdbinit
 !/.gitignore
 !/CMakeLists.txt
 !/Makefile
 !/README.md
+!/README.ru.md
 

CMakeLists.txt

@@ -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)
 
@@ -15,10 +21,122 @@ add_executable(fzc
 	src/compiler/fzl_walker.c
 	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
 add_executable(fz
 	src/vm/fzl_vm.c
+	src/vm/fzl_vm_env.c
+	src/vm/fzl_vm_debug.c
 	src/vm/main.c)
 
+#
+# ========== Compilation tests ==========
+#
+
+enable_testing()
+
+add_test(
+	NAME compile_hw
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/hw.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/hw.fzs"
+)
+add_test(
+	NAME compile_print_empty
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/print_empty.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/print_empty.fzs"
+)
+add_test(
+	NAME compile_problematic_hw
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/problematic_hw.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/problematic_hw.fzs"
+)
+add_test(
+	NAME compile_base_math
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/base_math.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/base_math.fzs"
+)
+add_test(
+	NAME compile_variables
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/variables.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/variables.fzs"
+)
+add_test(
+	NAME compile_conditions
+	COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/conditions.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/conditions.fzs"
+)
+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)
+
+#
+# ========== Runtime tests ==========
+#
+
+add_test(
+	NAME runtime_hw
+	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/hw.fzb"
+)
+add_test(
+	NAME runtime_print_empty
+	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/print_empty.fzb"
+)
+add_test(
+	NAME runtime_base_math
+	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/base_math.fzb"
+)
+add_test(
+	NAME runtime_variables
+	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/variables.fzb"
+)
+add_test(
+	NAME runtime_conditions
+	COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/conditions.fzb"
+)
+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"
+)
+

Makefile

@@ -1,4 +1,4 @@
-.PHONY: configure build
+.PHONY: configure build debug-c debug-vm test
 
 configure:
 	cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
@@ -6,3 +6,12 @@ configure:
 build: configure
 	cmake --build build
 
+debug-c: build
+	gdb --args ./build/fzc ${FILE}
+
+debug-vm: build
+	gdb --args ./build/fz ${FILE}
+
+test: build
+	ctest --output-on-failure --test-dir build
+

README.md

@@ -0,0 +1,61 @@
+# FromZero / Language
+
+[README in Russian](./README.ru.md)
+
+**FromZero/Language** is a package consisting of a JIT compiler and a virtual machine for the FZL language.
+
+## Features
+
+At the moment, the language has the following capabilities:
+
+- Builtin `printline` function for printing argument to stdout
+- String and numeric literals
+- Arithmetic operations: addition, subtraction, multiplication, division, modulo, power
+- Variables declaration with following types:
+  - `uint`, `int` - for the machine-word size integers
+  - `i8`..`i64` - integers with specified size
+  - `u8`..`u64` - unsigned integers with specified size
+  - `str` - strings
+  - `bool` - boolean
+- Assignments
+- Functions
+- Classes and objects
+
+Working examples of code can be found in `exl/` directory.
+
+
+## File extensions
+
+Standard file extensions:
+
+- `.fzs` - source code
+- `.fzb` - compiled binary file
+
+
+## Building
+
+1. Clone the repository: `git clone https://git.samsonium.dev/samsonium/fz-lang.git`
+2. Build: `make build`
+
+After this, a "build" directory will appear in the project root. It will contain two executable files:
+
+- `fzc` - a compiler
+- `fz` - virtual machine
+
+Both executables have usage help that can be displayed using `--help` flag (or `-h`).
+
+
+## Development guideline
+
+You need a code editor with Clang LSP support because of `.clang-format` file in the project root.
+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`.
+

README.ru.md

@@ -0,0 +1,61 @@
+# FromZero / Language
+
+[README in English](./README.md)
+
+**FromZero/Language** - пакет из JIT-компилятора и виртуальной машины для языка FZL.
+
+## Текущие возможности
+
+На данный момент язык имеет:
+
+- Встроенную функцию `printline` для вывода аргумента в stdout
+- Строковый, булев и числовой литералы
+- Арифметические операции: сложение, вычитание, умножение, деление, модуло, возведение в степень
+- Декларация переменных со следующими типами:
+  - `uint`, `int` - целые числа размером с машинное слово
+  - `i8`..`i64` - целые числа со знаком
+  - `u8`..`u64` - целые числа без знака
+  - `str` - строки
+  - `bool` - булевы
+- Присваивание
+- Функции
+- Классы и объекты
+
+Примеры кода лежат в директории `exl/`.
+
+
+## Расширения файлов
+
+Стандартными для языка являются два расширения файлов:
+
+- `.fzs` - исходный код
+- `.fzb` - скомпилированный бинарный файл
+
+
+## Инструкции по сборке
+
+1. Склонировать проект: `git clone https://git.samsonium.dev/samsonium/fz-lang.git`
+2. Собрать проект: `make build`
+
+После этого в корне появится директория **"build"**. В ней будут лежать два скомпилированных бинарных файла:
+
+- `fzc` - компилятор
+- `fz` - виртуальная машина
+
+Оба бинарных файла предоставляют справку по использованию при запуске с флагом `--help` (или `-h`).
+
+
+## Гайдлайн по разработке
+
+Желательно иметь редактор кода, поддерживающий Clang LSP, так как в проекте есть готовые настройки для
+форматтера в виде файла `.clang-format`.
+
+Для дебаггинга есть два таргета в CMake: `build-c` для компилятора и `build-vm` для виртуальной машины.
+Оба таргета позволяют указать переменную с путём файла. Например, так:
+
+```shell
+$ make debug-c FILE=exl/hw.fzs
+```
+
+Для проверки новых фич, нужно использовать make-таргет `test`, а тесты писать в `CMakeLists.txt`.
+

exl/base_math.fzs

@@ -0,0 +1,7 @@
+printline(2 + 2 * 2);
+printline(-1 + 1);
+printline(2 ^ 2);
+printline(1 + 1 * 1 / 1);
+printline(4 % 2);
+printline(10 / 2);
+

exl/borrow.fzs

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

exl/class.fzs

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

exl/comment.fzs

@@ -0,0 +1,3 @@
+// I'm a comment
+printline("Comment is skipped");;;;;
+

exl/conditions.fzs

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

exl/fn.fzs

@@ -0,0 +1,32 @@
+fn fib(int n) int
+{
+  if (n <= 1)
+    return n;
+
+  return fib(n - 1) + fib(n - 2);
+}
+
+fn sum(uint a, uint b) uint
+{
+  return a + b;
+}
+
+printline("Test #1: fibonacci");
+int result = fib(7);
+if (result == 13)
+  printline("Recurse test passed");
+else
+{
+  printline("Recurse test failed");
+  exit(1);
+}
+
+printline("Test #2: sum");
+if (sum(2, 2) == 4)
+  printline("Sum test passed");
+else
+{
+  printline("Sum test failed");
+  exit(1);
+}
+

exl/hard-1.fzs

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

exl/hw.fzs

@@ -1,2 +1,2 @@
-printline('hello, world')
+printline('hello, world');
 

exl/print_empty.fzs

@@ -1 +1 @@
-printline("")
+printline("");

exl/problematic_hw.fzs

@@ -1 +1 @@
-printline("hello)
+printline("hello);

exl/raii.fzs

@@ -0,0 +1,46 @@
+class Animal
+{
+  str type;
+  str name;
+  int age;
+
+  fn copy() Animal
+  {
+    Animal cp = new Animal;
+    cp.type = this.type;
+    cp.name = this.name;
+    cp.age = this.age;
+
+    return cp;
+  }
+}
+
+Animal a = new Animal;
+a.type = "Cow";
+a.name = "Buryatka";
+a.age = 5;
+
+Animal b = a.copy();
+b.name = "Gavryusha";
+b.age = 10;
+
+printline(a);
+printline(b);
+
+printline("Types are same:");
+printline(a.type == b.type);
+
+printline("Names are NOT the same");
+printline(a.name != b.name);
+
+printline("1st age less than 2nd");
+printline(a.age < b.age);
+
+if (a.type == b.type && a.name != b.name && a.age < b.age)
+  printline("Test passed");
+else
+{
+  printline("Test failed");
+  exit(1);
+}
+

exl/variables.fzs

@@ -0,0 +1,13 @@
+uint work_it = 21 * 2 ^ 2;
+int  make_it = 10;
+
+u64  do_it;
+do_it = 15;
+
+printline(work_it);
+printline(make_it + do_it);
+
+char make_us;
+str floyd = "hello, Pink Floyd!";
+printline(floyd);
+

include/common/fzl_builtins.h

@@ -3,7 +3,8 @@
 
 typedef enum
 {
-  FZL_BUILTIN_PRINTLINE // Print message in arg with newline at end
+  FZL_BUILTIN_PRINTLINE, // Print message in arg with newline at end
+  FZL_BUILTIN_EXIT,      // Exit program with code specified in arg
 } fzl_builtin_t;
 
 #endif // FZL_BUILTINS_H

include/common/fzl_colors.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

include/common/fzl_opcodes.h

@@ -4,9 +4,54 @@
 // Available opcodes
 typedef enum
 {
-  FZL_OPCODE_LOADCONST,   // Load const into T (temp) reg
+  FZL_OPCODE_LOADCONST    = 0xF00001, // Load const into T (temp) reg
-  FZL_OPCODE_PUSHARG,     // Push argument from T into args stack
+  FZL_OPCODE_CALL_BUILTIN = 0xF00002, // Call builtin function
-  FZL_OPCODE_CALL_BUILTIN // Call builtin function
+  FZL_OPCODE_PUSHNUM      = 0xF00003, // Push number into stack
+  FZL_OPCODE_PUSHBOOL     = 0xF00004, // Push boolean into stack
+
+  FZL_OPCODE_MK_ENVTABLE = 0xF10001, // Allocate new environment table
+  FZL_OPCODE_RM_ENVTABLE = 0xF10002, // Free environment table
+  FZL_OPCODE_STORE       = 0xF10003, // Push variable to environment table
+  FZL_OPCODE_LOOKUP_ENV  = 0xF10004, // Lookup name in environment table
+  FZL_OPCODE_WRITE       = 0xF10005, // Wirte into variable
+
+  FZL_OPCODE_JMP = 0xF20001, // Jump to specified IP address
+  FZL_OPCODE_JZ  = 0xF20002, // Jump if top value in dstack is zero
+
+  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
+  FZL_OPCODE_DIV = 0xA00004, // Divide two numbers in dstack
+  FZL_OPCODE_POW = 0xA00005, // Power first number in dstack by second
+  FZL_OPCODE_MOD = 0xA00006, // Get module of two numbers in dstack
+  FZL_OPCODE_NEG = 0xA00007, // Negotiate number in dstack
+
+  FZL_OPCODE_CMP_EQ   = 0xB00001, // Equal
+  FZL_OPCODE_CMP_NEQ  = 0xB00002, // Not equal
+  FZL_OPCODE_CMP_LT   = 0xB00003, // Less than
+  FZL_OPCODE_CMP_LTEQ = 0xB00004, // Less than or equal
+  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
+
+  FZL_OPCODE_NOT = 0xD00001, // !A
 } fzl_opcode_t;
 
 #endif // FZL_OPCODES_H

include/common/fzl_types.h

@@ -0,0 +1,25 @@
+#ifndef FZL_TYPES_H
+#define FZL_TYPES_H
+
+typedef enum
+{
+  FZL_TYPE_NULL,
+  FZL_TYPE_OBJECT,
+
+  FZL_TYPE_STRING,
+  FZL_TYPE_CHAR,
+  FZL_TYPE_BOOL,
+
+  FZL_TYPE_INT8,
+  FZL_TYPE_UINT8,
+  FZL_TYPE_INT16,
+  FZL_TYPE_UINT16,
+  FZL_TYPE_INT32,
+  FZL_TYPE_UINT32,
+  FZL_TYPE_INT64,
+  FZL_TYPE_UINT64,
+  FZL_TYPE_INT, // machine word int
+  FZL_TYPE_UINT // machine word unsigned int
+} fzl_type_t;
+
+#endif // FZL_TYPES_H

include/common/fzl_value.h

@@ -0,0 +1,44 @@
+#ifndef FZL_VALUE_H
+#define FZL_VALUE_H
+
+#include <common/fzl_types.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+// Value container descriptor
+typedef struct
+{
+  fzl_type_t type;
+
+  union
+  {
+    void *obj;
+
+    struct
+    {
+      const char *value;
+      size_t length;
+    } s;
+
+    char c;
+    bool b;
+
+    int8_t i8;
+    uint8_t u8;
+
+    int16_t i16;
+    uint16_t u16;
+
+    int32_t i32;
+    uint32_t u32;
+
+    int64_t i64;
+    uint64_t u64;
+
+    intptr_t i;
+    uintptr_t u;
+  } as;
+} fzl_value_t;
+
+#endif // FZL_VALUE_H

include/compiler/fzl_parser.h

@@ -11,6 +11,38 @@ typedef enum
   FZL_NODETYPE_BLOCK,
   FZL_NODETYPE_CALL,
   FZL_NODETYPE_LITERAL,
+  FZL_NODETYPE_IDENTIFIER,
+  FZL_NODETYPE_CONDITIONAL,
+  FZL_NODETYPE_FUNCTION,
+  FZL_NODETYPE_RETURN,
+  FZL_NODETYPE_CLASS,
+  FZL_NODETYPE_FIELD,
+  FZL_NODETYPE_CONSTRUCT,
+
+  FZL_NODETYPE_ADD,
+  FZL_NODETYPE_SUB,
+  FZL_NODETYPE_MUL,
+  FZL_NODETYPE_DIV,
+  FZL_NODETYPE_POW,
+  FZL_NODETYPE_MOD,
+
+  FZL_NODETYPE_UNARY_PLUS,
+  FZL_NODETYPE_UNARY_MINUS,
+
+  FZL_NODETYPE_OR,
+  FZL_NODETYPE_AND,
+
+  FZL_NODETYPE_EQUAL,
+  FZL_NODETYPE_NEQUAL,
+  FZL_NODETYPE_LESS,
+  FZL_NODETYPE_LESS_EQUAL,
+  FZL_NODETYPE_GREATER,
+  FZL_NODETYPE_GREATER_EQUAL,
+
+  FZL_NODETYPE_NOT,
+
+  FZL_NODETYPE_DECLARATION,
+  FZL_NODETYPE_ASSIGN
 } fzl_nodetype_t;
 
 // AST node descriptor
@@ -23,11 +55,91 @@ typedef struct fzl_node
 
   union
   {
+    // Array of nested nodes (for blocks, etc)
     struct
     {
       struct fzl_node **entries;
       size_t entry_count;
     } list;
+
+    // Call data
+    struct
+    {
+      struct fzl_node *callee;
+
+      struct fzl_node **args;
+      size_t args_count;
+    } call;
+
+    // Binary operations
+    struct
+    {
+      struct fzl_node *left;
+      struct fzl_node *right;
+    } binary_op;
+
+    // Unary operations
+    struct
+    {
+      struct fzl_node *operand;
+    } unary_op;
+
+    // Variables declaration and initializing
+    struct
+    {
+      fzl_token_t *type;
+      struct fzl_node *identifier;
+    } var;
+
+    // Conditional blocks
+    struct
+    {
+      struct fzl_node *condition;
+      struct fzl_node *true_block;
+      struct fzl_node *else_block;
+    } cond;
+
+    // Function declaration
+    struct
+    {
+      struct fzl_node **args;
+      size_t args_count;
+
+      struct fzl_node *body;
+      fzl_token_t *name;
+      fzl_token_t *type;
+    } fn;
+
+    // Return value
+    struct
+    {
+      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;
 

include/compiler/fzl_reader.h

@@ -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,14 +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;
-  bool at_end;
 } 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);

include/compiler/fzl_token.h

@@ -8,27 +8,70 @@
 // Token type
 typedef enum
 {
-  FZL_TOKTYPE_NAME,
+  FZL_TOKTYPE_CLASS, // class
-  FZL_TOKTYPE_LPAIR,
+  FZL_TOKTYPE_NEW,   // new
-  FZL_TOKTYPE_RPAIR,
+
-  FZL_TOKTYPE_COMMA,
+  FZL_TOKTYPE_FUNCTION, // fn
-  FZL_TOKTYPE_STR_LITERAL
+  FZL_TOKTYPE_RETURN,   // return
+
+  FZL_TOKTYPE_IF,   // if
+  FZL_TOKTYPE_ELSE, // else
+
+  FZL_TOKTYPE_NAME, // abc
+  FZL_TOKTYPE_TYPE, // i16
+
+  FZL_TOKTYPE_DDASH, // // :D
+
+  FZL_TOKTYPE_LPAREN, // (
+  FZL_TOKTYPE_RPAREN, // )
+  FZL_TOKTYPE_LBRACE, // {
+  FZL_TOKTYPE_RBRACE, // }
+
+  FZL_TOKTYPE_COMMA,     // ,
+  FZL_TOKTYPE_DOT,       // .
+  FZL_TOKTYPE_SEMICOLON, // ;
+
+  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,      // ||
+
+  FZL_TOKTYPE_EQEQ,   // ==
+  FZL_TOKTYPE_REQ,    // >=
+  FZL_TOKTYPE_LEQ,    // <=
+  FZL_TOKTYPE_NEQ,    // !=
+  FZL_TOKTYPE_LANGLE, // <
+  FZL_TOKTYPE_RANGLE, // >
+  FZL_TOKTYPE_NOT,    // !
+
+  FZL_TOKTYPE_STAR,    // *
+  FZL_TOKTYPE_SLASH,   // /
+  FZL_TOKTYPE_PLUS,    // +
+  FZL_TOKTYPE_MINUS,   // -
+  FZL_TOKTYPE_CARET,   // ^
+  FZL_TOKTYPE_PERCENT, // %
+
+  FZL_TOKTYPE_EQ // =
 } fzl_toktype_t;
 
 // Token descriptor
 typedef struct
 {
   fzl_toktype_t type;
-  uint16_t i0;
+  size_t ln;
-  uint16_t i1;
+  size_t cn;
   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, uint16_t from, uint16_t to,
+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);

include/compiler/fzl_walker.h

@@ -2,10 +2,44 @@
 #define FZL_WALKER_H
 
 #include <common/fzl_opcodes.h>
+#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
+{
+  fzl_type_t type;
+
+  char *error_msg;
+  bool error;
+
+  char *classname;
+} fzl_walk_res_t;
+
+// Function context descriptor
+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;
+
 // Walker descriptor
 typedef struct
 {
@@ -15,6 +49,14 @@ typedef struct
   uint64_t *ops;
   size_t op_count;
   size_t op_remainder;
+
+  fzl_symtable_t *syms[64];
+  size_t sym_top;
+
+  fzl_walk_ctx_t *ctx;
+
+  fzl_ctable_t *classes[64];
+  size_t classes_count;
 } fzl_walker_t;
 
 // Allocate new walker

include/compiler/utils/fzl_const_pool.h

@@ -4,11 +4,12 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>
 
 // Constant types
 typedef enum
 {
-  FZL_CONSTTYPE_STRING
+  FZL_CONSTTYPE_STRING,
 } fzl_consttype_t;
 
 // Constant descriptor
@@ -23,12 +24,17 @@ typedef struct
       const char *chars;
       size_t length;
     } string;
+
+    struct
+    {
+      uint64_t value;
+    } num;
   } as;
 } fzl_const_t;
 
 typedef struct
 {
-  size_t pool_index;
+  ssize_t pool_index;
 } fzl_const_hash_slot_t;
 
 // Constant pool descriptor
@@ -47,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);

include/compiler/utils/fzl_ctable.h

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

include/compiler/utils/fzl_linked.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

include/compiler/utils/fzl_options.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

include/compiler/utils/fzl_symtable.h

@@ -0,0 +1,53 @@
+#ifndef FZL_SYMTABLE_H
+#define FZL_SYMTABLE_H
+
+#include <common/fzl_types.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+typedef enum
+{
+  FZL_SYMTABLE_RESULT_OK,
+  FZL_SYMTABLE_RESULT_ERR,
+  FZL_SYMTABLE_RESULT_EXISTS,
+  FZL_SYMTABLE_RESULT_NOT_OBJECT
+} fzl_symtable_res_t;
+
+// Symbols table entry descriptor
+typedef struct
+{
+  char *name;
+  fzl_type_t type;
+  size_t ip;
+
+  char *classname;
+} fzl_sym_t;
+
+// Symbols table descriptor
+typedef struct
+{
+  size_t size;
+  size_t remainder;
+
+  fzl_sym_t *symbols;
+} fzl_symtable_t;
+
+// Allocate new symbtable
+fzl_symtable_t *fzl_mksymt();
+
+// Put new entry into symtable
+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);
+
+// Free symbtable
+void fzl_freesymt(fzl_symtable_t *symt);
+
+#endif // FZL_SYMTABLE_H

include/vm/fzl_vm.h

@@ -1,9 +1,12 @@
 #ifndef FZL_VM_H
 #define FZL_VM_H
 
+#include <common/fzl_value.h>
 #include <compiler/utils/fzl_const_pool.h> // NOTE: move outside compiler scope to common
 #include <stddef.h>
 #include <stdint.h>
+#include <vm/fzl_vm_env.h>
+#include <vm/fzl_vm_object.h>
 
 // VM descriptor
 typedef struct
@@ -16,11 +19,17 @@ typedef struct
 
   size_t ip;
 
-  fzl_const_t stack[256];
+  // Data stack
-  size_t stack_top;
+  fzl_value_t dstack[256];
+  size_t dtop;
 
-  fzl_const_t arg_stack[256];
+  // Call stack
-  size_t arg_top;
+  size_t cstack[256];
+  size_t ctop;
+
+  // Environment stack
+  fzl_vm_env_t *estack[256];
+  size_t etop;
 } fzl_vm_t;
 
 // Allocate FZL VM
@@ -32,6 +41,9 @@ int fzl_vm_run(fzl_vm_t *vm);
 // Get last VM error message
 char *fzl_vm_geterror();
 
+// Print opcodes sequence
+void fzl_vm_print_ops(fzl_vm_t *vm);
+
 // Free VM
 void fzl_freevm(fzl_vm_t *vm);
 

include/vm/fzl_vm_env.h

@@ -0,0 +1,57 @@
+#ifndef FZL_VM_ENV_H
+#define FZL_VM_ENV_H
+
+#include <common/fzl_value.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <vm/fzl_vm_object.h>
+
+typedef enum
+{
+  FZL_VM_ENV_WRESULT_OK,
+  FZL_VM_ENV_WRESULT_ERR,
+  FZL_VM_ENV_WRESULT_ERR_EXISTS,
+  FZL_VM_ENV_WRESULT_ERR_NOT_FOUND
+} fzl_vm_env_wresult_t;
+
+// Environment table entry descriptor
+typedef struct
+{
+  char *name;
+  fzl_value_t value;
+} fzl_vm_env_entry_t;
+
+// Environment table descriptor
+typedef struct
+{
+  size_t size;
+  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
+fzl_vm_env_t *fzl_mkenv();
+
+// Try get value by name
+bool fzl_env_lookup(fzl_vm_env_t *env, char *name, fzl_value_t *res);
+
+// Check name in env table
+bool fzl_env_contains(fzl_vm_env_t *env, char *name);
+
+// Store new value
+fzl_vm_env_wresult_t fzl_env_storevalue(fzl_vm_env_t *env, char *name,
+                                        fzl_value_t val);
+
+// Overwrite existing value
+fzl_vm_env_wresult_t fzl_env_writevalue(fzl_vm_env_t *env, char *name,
+                                        fzl_value_t newval);
+
+// Free env table
+void fzl_freeenv(fzl_vm_env_t *env);
+
+#endif // FZL_VM_ENV_H

include/vm/fzl_vm_object.h

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

src/compiler/fzl_debug.c

@@ -1,3 +1,4 @@
+#include "compiler/fzl_parser.h"
 #include <compiler/fzl_debug.h>
 #include <stddef.h>
 #include <stdio.h>
@@ -26,18 +27,52 @@ 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);
+      print_node(node->var.identifier, level + 1);
+      break;
+
+    case FZL_NODETYPE_ASSIGN:
+      printf("%s Assign:\n", levelbuf);
+      printf("-%s Target:\n", levelbuf);
+      print_node(node->binary_op.left, level + 2);
+      printf("-%s Source:\n", levelbuf);
+      print_node(node->binary_op.right, level + 2);
+      break;
+
     case FZL_NODETYPE_CALL:
-    if (node->list.entry_count > 0)
+      if (node->call.args_count > 0)
       {
         printf("%s Call fn '%s' with args:\n", levelbuf,
                (char *)node->token->value);
-      for (size_t i = 0; i < node->list.entry_count; i++)
+        for (size_t i = 0; i < node->call.args_count; i++)
-        print_node(node->list.entries[i], level + 1);
+          print_node(node->call.args[i], level + 1);
       }
       else
         printf("%s Call fn '%s' w/o args\n", levelbuf,
@@ -48,6 +83,19 @@ void print_node(fzl_node_t *node, int level)
       printf("%s Literal '%s'\n", levelbuf, (char *)node->token->value);
       break;
 
+    case FZL_NODETYPE_CONDITIONAL:
+      printf("%s Conditional block:\n", levelbuf);
+      printf("-%s Condition:\n", levelbuf);
+      print_node(node->cond.condition, level + 2);
+      printf("-%s True block:\n", levelbuf);
+      print_node(node->cond.true_block, level + 2);
+      if (node->cond.else_block)
+      {
+        printf("-%s Else block:\n", levelbuf);
+        print_node(node->cond.else_block, level + 2);
+      }
+      break;
+
     case FZL_NODETYPE_BLOCK:
       printf("%s Block: ", levelbuf);
 
@@ -63,6 +111,52 @@ void print_node(fzl_node_t *node, int level)
 
       break;
 
+    case FZL_NODETYPE_NOT:
+      printf("%s Inverse:\n", levelbuf);
+      print_node(node->unary_op.operand, level + 1);
+      break;
+
+    case FZL_NODETYPE_FUNCTION:
+      printf("%s Function named '%s' with ret type '%s':\n", levelbuf,
+             (char *)node->fn.name->value, (char *)node->fn.type->value);
+      printf("-%s Args:\n", levelbuf);
+      for (size_t i = 0; i < node->fn.args_count; i++)
+        print_node(node->fn.args[i], level + 2);
+      printf("-%s Body:\n", levelbuf);
+      print_node(node->fn.body, level + 2);
+      break;
+
+    case FZL_NODETYPE_RETURN:
+      printf("%s Return:\n", levelbuf);
+      if (node->ret.value)
+        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:
+    case FZL_NODETYPE_LESS_EQUAL:
+    case FZL_NODETYPE_GREATER:
+    case FZL_NODETYPE_GREATER_EQUAL:
+    case FZL_NODETYPE_ADD:
+    case FZL_NODETYPE_SUB:
+    case FZL_NODETYPE_MUL:
+    case FZL_NODETYPE_DIV:
+    case FZL_NODETYPE_POW:
+    case FZL_NODETYPE_MOD:
+      printf("%s Binary op (%d)\n", levelbuf, node->type);
+      printf("-%s LEFT:\n", levelbuf);
+      print_node(node->binary_op.left, level + 2);
+      printf("-%s RIGHT:\n", levelbuf);
+      print_node(node->binary_op.right, level + 2);
+      break;
+
+    case FZL_NODETYPE_IDENTIFIER:
+      printf("%s Identifier ('%s')\n", levelbuf, (char *)node->token->value);
+      break;
+
     default:
       printf("%s Secure node\n", levelbuf);
   }

src/compiler/fzl_reader.c

@@ -1,5 +1,8 @@
+#include "compiler/fzl_token.h"
+#include "compiler/utils/fzl_linked.h"
 #include <compiler/fzl_reader.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -7,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;
@@ -16,16 +19,26 @@ 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->linked       = linked;
-  reader->size = strlen(source);
+  reader->source       = linked->source;
+  reader->size         = linked->total_sz;
   reader->position     = 0;
-  reader->at_end = true;
 
   return reader;
 }
 
 // --- Read zone ---
 
+// Move cursor forward
+// @deprecated
+static size_t move(fzl_reader_t *reader, size_t len)
+{
+  if (!reader)
+    return 0;
+
+  return reader->position += len;
+}
+
 // Try parse name
 fzl_token_t *parse_name(fzl_reader_t *reader)
 {
@@ -37,16 +50,57 @@ fzl_token_t *parse_name(fzl_reader_t *reader)
     lpos++;
     size++;
   } while ((reader->source[lpos] >= 'A' && reader->source[lpos] <= 'Z') ||
-           (reader->source[lpos] >= 'a' && reader->source[lpos] <= 'z'));
+           (reader->source[lpos] >= 'a' && reader->source[lpos] <= 'z') ||
+           (reader->source[lpos] >= '0' && reader->source[lpos] <= '9') ||
+           (reader->source[lpos] == '_'));
 
-  char *value = malloc(size);
+  char *value = malloc(size + 1);
   memcpy(value, reader->source + reader->position, size);
+  value[size] = '\0';
 
   size_t start = reader->position;
-  reader->position += size;
+  move(reader, size);
 
-  fzl_token_t *tok =
+  fzl_token_t *tok;
-      fzl_mktoken(FZL_TOKTYPE_NAME, start, reader->position - 1, value, size);
+  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, "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, l.line, l.col, value, size, l.filename);
+  else if (strcmp(value, "else") == 0)
+    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, l.line, l.col, value, size,
+                      l.filename);
+  else if (strcmp(value, "null") == 0)
+    tok = fzl_mktoken(FZL_TOKTYPE_NULL_LITERAL, l.line, l.col, value, size,
+                      l.filename);
+  else if (strcmp(value, "str") == 0 || strcmp(value, "char") == 0 ||
+           strcmp(value, "bool") == 0 || strcmp(value, "uint") == 0 ||
+           strcmp(value, "int") == 0 || strcmp(value, "i8") == 0 ||
+           strcmp(value, "i16") == 0 || strcmp(value, "i32") == 0 ||
+           strcmp(value, "i64") == 0 || strcmp(value, "u8") == 0 ||
+           strcmp(value, "u16") == 0 || strcmp(value, "u32") == 0 ||
+           strcmp(value, "u64") == 0)
+    tok = fzl_mktoken(FZL_TOKTYPE_TYPE, l.line, l.col, value, size, l.filename);
+  else
+    tok = fzl_mktoken(FZL_TOKTYPE_NAME, l.line, l.col, value, size, l.filename);
   free(value);
 
   return tok;
@@ -75,28 +129,120 @@ fzl_token_t *parse_string_literal(fzl_reader_t *reader)
   } while (reader->source[lpos] != open_symbol && lpos < reader->size);
   size++;
 
-  if (close_symbol != open_symbol)
+  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), "'%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->position,
+    fzl_token_t *tok =
-                                   reader->position + 1, "", 0);
+        fzl_mktoken(FZL_TOKTYPE_STR_LITERAL, l.line, l.col, "", 0, l.filename);
-    reader->position += 2;
+    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->position,
+  fzl_token_t *tok = fzl_mktoken(FZL_TOKTYPE_STR_LITERAL, l.line, l.col, value,
-                                 lpos, value, size - 2);
+                                 size - 2, l.filename);
   free(value);
-
+  move(reader, size);
-  reader->position += size;
 
   return tok;
 }
 
+// Parse numeric literal
+fzl_token_t *parse_number(fzl_reader_t *reader)
+{
+  if (!reader)
+    return NULL;
+
+  size_t size = 0;
+  size_t lpos = reader->position;
+
+  do
+  {
+    size++;
+    lpos++;
+  } while ((reader->source[lpos] >= '0' && reader->source[lpos] <= '9') &&
+           lpos < reader->size);
+
+  char *value = malloc(size * sizeof(char) + 1);
+  memcpy(value, reader->source + reader->position, size);
+  value[size] = '\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;
+  }
+
+  fzl_token_t *tok = fzl_mktoken(FZL_TOKTYPE_NUM_LITERAL, l.line, l.col, value,
+                                 size, l.filename);
+  free(value);
+
+  if (!tok)
+    return NULL;
+
+  move(reader, size);
+  return tok;
+}
+
+// Add single-char token
+fzl_token_t *add_single(fzl_reader_t *reader, fzl_toktype_t type)
+{
+  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)
+{
+  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)
 {
   if (reader->position >= reader->size)
@@ -110,57 +256,110 @@ int fzl_read(fzl_reader_t *reader)
 
     if (curr == '\n' || curr == ' ' || curr == '\r')
     {
-      reader->position++;
+      move(reader, 1);
       continue;
     }
 
     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] == '=')
+      token = add_double(reader, FZL_TOKTYPE_REQ);
+    else if (curr == '<' && reader->source[p + 1] == '=')
+      token = add_double(reader, FZL_TOKTYPE_LEQ);
+    else if (curr == '!' && reader->source[p + 1] == '=')
+      token = add_double(reader, FZL_TOKTYPE_NEQ);
+    else if (curr == '|' && reader->source[p + 1] == '|')
+      token = add_double(reader, FZL_TOKTYPE_DVBAR);
+    else if (curr == '&' && reader->source[p + 1] == '&')
+      token = add_double(reader, FZL_TOKTYPE_DAMPERSAND);
+    else if (curr == '>')
+      token = add_single(reader, FZL_TOKTYPE_RANGLE);
+    else if (curr == '<')
+      token = add_single(reader, FZL_TOKTYPE_LANGLE);
+    else if (curr == '!')
+      token = add_single(reader, FZL_TOKTYPE_NOT);
+    else if (curr == ';')
+      token = add_single(reader, FZL_TOKTYPE_SEMICOLON);
+    else if (curr == '{')
+      token = add_single(reader, FZL_TOKTYPE_LBRACE);
+    else if (curr == '}')
+      token = add_single(reader, FZL_TOKTYPE_RBRACE);
     else if (curr == '(')
-    {
+      token = add_single(reader, FZL_TOKTYPE_LPAREN);
-      token = fzl_mktoken(FZL_TOKTYPE_LPAIR, p, p, NULL, 0);
-      reader->position++;
-    }
     else if (curr == ')')
-    {
+      token = add_single(reader, FZL_TOKTYPE_RPAREN);
-      token = fzl_mktoken(FZL_TOKTYPE_RPAIR, p, p, NULL, 0);
+    else if (curr == ',')
-      reader->position++;
+      token = add_single(reader, FZL_TOKTYPE_COMMA);
-    }
+    else if (curr == '.')
-    else if (curr >= 'A' && curr <= 'Z' || curr >= 'a' && curr <= 'z')
+      token = add_single(reader, FZL_TOKTYPE_DOT);
+    else if (curr == '*')
+      token = add_single(reader, FZL_TOKTYPE_STAR);
+    else if (curr == '/')
+      token = add_single(reader, FZL_TOKTYPE_SLASH);
+    else if (curr == '+')
+      token = add_single(reader, FZL_TOKTYPE_PLUS);
+    else if (curr == '-')
+      token = add_single(reader, FZL_TOKTYPE_MINUS);
+    else if (curr == '^')
+      token = add_single(reader, FZL_TOKTYPE_CARET);
+    else if (curr == '%')
+      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') ||
+             curr == '_')
       token = parse_name(reader);
+    else if (curr >= '0' && curr <= '9')
+      token = parse_number(reader);
     else
     {
-      sprintf(last_err, "undefined token '%c'", curr);
+      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)
     {
-      size_t line = 1, linepos = 1;
+      if (!last_err[0])
-      for (size_t i = 0; i < p; i++)
       {
-        char sym = reader->source[i];
+        fzl_file_loc l;
-        if (sym == '\n')
+        bool ok = fzl_linked_getpos(reader->linked, p, &l);
+        if (!ok)
         {
-          linepos = 1;
+          snprintf(last_err, sizeof(last_err), "failed to locate line:col");
-          line++;
+          return -1;
         }
-        else
+
-          linepos++;
+        sprintf(last_err, "'%s': cannot parse token at %ld:%ld", l.filename,
+                l.line, l.col);
       }
 
-      sprintf(last_err, "cannot parse token (%ld:%ld)", line, linepos);
       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;
     reader->last       = tok_node;
   } while (reader->position < reader->size);
 
-  reader->at_end = true;
   return 0;
 }
 

src/compiler/fzl_token.c

@@ -1,21 +1,28 @@
 #include <compiler/fzl_token.h>
+#include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 
-fzl_token_t *fzl_mktoken(const fzl_toktype_t type, uint16_t from, uint16_t to,
+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->i0 = from;
+  token->ln          = line;
-  token->i1 = to;
+  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;
 }

src/compiler/main.c

@@ -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);
+  fzl_options_t *opts = fzl_mkoptions(argc, argv);
-  if (args == NULL)
+  if (!opts)
+  {
+    fzl_freeoptions(opts);
     return -1;
-  else if (args->help)
+  }
+  else if (!opts->should_continue)
+  {
+    fzl_freeoptions(opts);
     return 0;
+  }
 
-  if (args->verbose)
+  if (opts->verbose)
-    printf("> analyze\n-> reading file...");
+    printf("%s> analyze\n-> reading file...%s", FZL_CDEBUG, FZL_CRST);
 
-  char *source;
+  fzl_linked_t *linked = fzl_mklinked();
-  FILE *fd = fopen(args->filepath, "r");
+  if (!linked)
-  if (!fd)
   {
-    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);
+  bool read_result =
-  size_t fsz = ftell(fd);
+      fzl_linked_add_files(linked, opts->files, opts->files_count);
-  rewind(fd);
+  if (!read_result)
-
-  source = malloc(fsz + 1);
-  fread(source, fsz, 1, fd);
-  fclose(fd);
-  source[fsz] = '\0';
-
-  if (args->verbose)
   {
-    printf("ok!\n");
+    char *lasterr = fzl_linked_geterror();
-    printf("--> Red %ld bytes\n", fsz);
+    if (lasterr[0])
-    printf("-> tokenizing...");
+      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)
+  if (opts->verbose)
-    printf("ok!\n");
+    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,79 +92,100 @@ 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("%s> building%s\n", FZL_CDEBUG, FZL_CRST);
-    printf("-> walking AST...\n");
+    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++)
-      printf("---> %lu\n", walker->ops[i]);
+    {
+      if (i > 0 && i < walker->op_count)
+        printf("->");
+      printf("%lu", walker->ops[i]);
+    }
+    printf("\n");
 
-    printf("-> preparing final write\n");
+    printf("%s-> preparing final write%s\n", FZL_CDEBUG, FZL_CRST);
   }
 
   char outpath[256];
-  if (args->outpath)
+  if (opts->outname)
-    strcpy(outpath, args->outpath);
+    strcpy(outpath, opts->outname);
   else
-    strcpy(outpath, "a.fzlc");
+    strcpy(outpath, "a.fzb");
 
-  if (args->verbose)
+  if (opts->verbose)
   {
-    printf("-> output file path is: %s", outpath);
+    printf("%s-> output file path is%s: %s\n", FZL_CDEBUG, FZL_CRST, outpath);
-    printf("-> writing file...");
+    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)
+  if (opts->verbose)
-    printf("ok!\n");
+    printf("%sok%s!\n", FZL_COK, FZL_CRST);
 
-  free(source);
+  fzl_freeoptions(opts);
-  free(args);
+  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;
 }

src/compiler/utils/fzl_const_pool.c

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

src/compiler/utils/fzl_ctable.c

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

src/compiler/utils/fzl_linked.c

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

src/compiler/utils/fzl_options.c

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

src/compiler/utils/fzl_symtable.c

@@ -0,0 +1,92 @@
+#include <common/fzl_types.h>
+#include <compiler/utils/fzl_symtable.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+fzl_symtable_t *fzl_mksymt()
+{
+  fzl_symtable_t *tbl = malloc(sizeof(fzl_symtable_t));
+  if (!tbl)
+    return NULL;
+
+  tbl->remainder = 2;
+  tbl->size      = 0;
+  tbl->symbols   = malloc(tbl->remainder * sizeof(fzl_sym_t));
+  if (!tbl->symbols)
+    return NULL;
+
+  return tbl;
+}
+
+fzl_symtable_res_t fzl_symt_put(fzl_symtable_t *symt, char *name,
+                                fzl_type_t type, uint64_t ip)
+{
+  if (!symt)
+    return FZL_SYMTABLE_RESULT_ERR;
+
+  for (size_t i = 0; i < symt->size; i++)
+    if (strcmp(symt->symbols[i].name, name) == 0)
+      return FZL_SYMTABLE_RESULT_EXISTS;
+
+  if (symt->remainder <= symt->size)
+  {
+    symt->remainder *= 2;
+    symt->symbols = realloc(symt->symbols, symt->remainder * sizeof(fzl_sym_t));
+  }
+
+  symt->symbols[symt->size++] =
+      (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)
+    return false;
+
+  for (size_t i = 0; i < symt->size; i++)
+  {
+    if (strcmp(symt->symbols[i].name, name) == 0)
+    {
+      *res = symt->symbols[i];
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void fzl_freesymt(fzl_symtable_t *symt)
+{
+  if (!symt)
+    return;
+
+  if (symt->symbols)
+    free(symt->symbols);
+
+  free(symt);
+}

src/vm/fzl_vm.c

@@ -1,11 +1,16 @@
-#include "common/fzl_builtins.h"
+#include <common/fzl_builtins.h>
-#include "common/fzl_opcodes.h"
+#include <common/fzl_opcodes.h>
-#include "compiler/utils/fzl_const_pool.h"
+#include <common/fzl_types.h>
+#include <common/fzl_value.h>
+#include <compiler/utils/fzl_const_pool.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
+#include <vm/fzl_vm_env.h>
+#include <vm/fzl_vm_object.h>
 
 char last_err[256];
 
@@ -25,15 +30,19 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
   vm->ops          = NULL;
   vm->ops_count    = 0;
   vm->ip           = 0;
-  memset(vm->stack, 0, sizeof(vm->stack));
+  vm->dtop         = 0;
-  vm->stack_top = 0;
+  vm->ctop         = 0;
-  memset(vm->arg_stack, 0, sizeof(vm->arg_stack));
+  vm->etop         = 0;
-  vm->arg_top = 0;
+
+  memset(vm->dstack, 0, sizeof(vm->dstack));
+  memset(vm->cstack, 0, sizeof(vm->cstack));
+  memset(vm->estack, 0, sizeof(vm->estack));
 
   FILE *fd = fopen(filepath, "rb");
   if (!fd)
   {
     snprintf(last_err, sizeof(last_err), "failed to open file '%s'", filepath);
+    free(vm);
     return NULL;
   }
 
@@ -42,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;
   }
 
@@ -52,13 +63,15 @@ 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;
   }
 
   if (consts_count > 0)
   {
     vm->consts_count = consts_count;
-    vm->consts = malloc(consts_count * sizeof(fzl_const_t));
+    vm->consts       = malloc(consts_count * sizeof(fzl_value_t));
 
     for (size_t i = 0; i < consts_count; i++)
     {
@@ -81,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;
@@ -96,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)
@@ -111,50 +284,717 @@ int fzl_vm_run(fzl_vm_t *vm)
   vm->ip = 0;
   while (vm->ip < vm->ops_count)
   {
-    uint64_t opcode = vm->ops[vm->ip];
+    fzl_opcode_t opcode = vm->ops[vm->ip];
 
     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];
+        vm->cstack[vm->ctop++] = vm->ip;
+        vm->ip                 = ip - 1;
+        break;
+      }
+
+      case FZL_OPCODE_RET:
+      {
+        if (vm->ctop < 1)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - no place to jump");
+          print_err_data(vm);
+          return -1;
+        }
+
+        vm->ip = vm->cstack[--vm->ctop];
+        break;
+      }
+
+      case FZL_OPCODE_CMP_EQ:
+        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 req = vm->dstack[--vm->dtop];
+        fzl_value_t leq = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = leq.as.u == req.as.u};
+        break;
+
+      case FZL_OPCODE_CMP_NEQ:
+        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 rneq       = vm->dstack[--vm->dtop];
+        fzl_value_t lneq       = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] = (fzl_value_t){.type = FZL_TYPE_BOOL,
+                                               .as.b = lneq.as.u != rneq.as.u};
+        break;
+
+      case FZL_OPCODE_CMP_LT:
+        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 rlt = vm->dstack[--vm->dtop];
+        fzl_value_t llt = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = llt.as.u < rlt.as.u};
+        break;
+
+      case FZL_OPCODE_CMP_LTEQ:
+        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 rlteq      = vm->dstack[--vm->dtop];
+        fzl_value_t llteq      = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] = (fzl_value_t){
+            .type = FZL_TYPE_BOOL, .as.b = llteq.as.u <= rlteq.as.u};
+        break;
+
+      case FZL_OPCODE_CMP_GT:
+        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 rgt = vm->dstack[--vm->dtop];
+        fzl_value_t lgt = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = lgt.as.u > rgt.as.u};
+        break;
+
+      case FZL_OPCODE_CMP_GTEQ:
+        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 rgteq      = vm->dstack[--vm->dtop];
+        fzl_value_t lgteq      = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] = (fzl_value_t){
+            .type = FZL_TYPE_BOOL, .as.b = lgteq.as.u >= rgteq.as.u};
+        break;
+
+      case FZL_OPCODE_NOT:
+        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 notval = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = !notval.as.b};
+        break;
+
+      case FZL_OPCODE_JZ:
+        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 jzval = vm->dstack[--vm->dtop];
+        uint64_t jzip     = vm->ops[++vm->ip] - 1;
+        if (jzval.as.b == 0)
+          vm->ip = jzip;
+        break;
+
+      case FZL_OPCODE_JMP:
+      {
+        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;
+        }
+
+        fzl_value_t land       = vm->dstack[--vm->dtop];
+        fzl_value_t rand       = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] = (fzl_value_t){.type = FZL_TYPE_BOOL,
+                                               .as.b = land.as.b && rand.as.b};
+        break;
+
+      case FZL_OPCODE_OR:
+        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 lor = vm->dstack[--vm->dtop];
+        fzl_value_t ror = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = lor.as.b || ror.as.b};
+        break;
+
+      case FZL_OPCODE_STORE:
+        if (vm->dtop < 1)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - expected var name in data stack");
+          print_err_data(vm);
+          return -1;
+        }
+
+        fzl_value_t varname = vm->dstack[--vm->dtop];
+        fzl_env_storevalue(vm->estack[vm->etop - 1], (char *)varname.as.s.value,
+                           (fzl_value_t){});
+
+        break;
+
+      case FZL_OPCODE_WRITE:
+        if (vm->dtop < 2)
+        {
+          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];
+
+        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)
+          {
+            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;
+          }
+        }
+
+        // vm->dstack[vm->dtop++] = value;
+        // NOTE: add POP opcode to prevent
+        // stack overflow!
+        break;
+
+      case FZL_OPCODE_MK_ENVTABLE:
+        vm->estack[vm->etop++] = fzl_mkenv();
+        break;
+
+      case FZL_OPCODE_RM_ENVTABLE:
+        fzl_freeenv(vm->estack[--vm->etop]);
+        break;
+
+      case FZL_OPCODE_LOOKUP_ENV:
+      {
+        if (vm->dtop < 1)
+        {
+          snprintf(last_err, sizeof(last_err),
+                   "runtime error - LOOKUP_ENV: empty data stack");
+          print_err_data(vm);
+          return -1;
+        }
+
+        fzl_value_t val = vm->dstack[--vm->dtop];
+        fzl_value_t env_val;
+        bool result;
+        for (ssize_t i = vm->etop - 1; i >= 0; i--)
+        {
+          if ((result = fzl_env_lookup(vm->estack[i], (char *)val.as.s.value,
+                                       &env_val)))
+            break;
+        }
+        vm->dstack[vm->dtop++] = env_val;
+
+        break;
+      }
+
       case FZL_OPCODE_CALL_BUILTIN:
+      {
         uint64_t fn_id = vm->ops[++vm->ip];
         if (fn_id == FZL_BUILTIN_PRINTLINE)
         {
-        fzl_const_t arg = vm->arg_stack[--vm->arg_top];
+          fzl_value_t arg = vm->dstack[--vm->dtop];
-        printf("%s\n", arg.as.string.chars);
+          if (arg.type == FZL_TYPE_STRING)
+            printf("%s\n", arg.as.s.value);
+          else if (arg.type == FZL_TYPE_CHAR)
+            printf("%c\n", arg.as.c);
+          else if (arg.type == FZL_TYPE_INT)
+            printf("%ld\n", arg.as.i);
+          else if (arg.type == FZL_TYPE_UINT)
+            printf("%lu\n", arg.as.u);
+          else if (arg.type == FZL_TYPE_BOOL)
+            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;
         }
-
+      }
       break;
 
       case FZL_OPCODE_LOADCONST:
+      {
         uint64_t cn = vm->ops[++vm->ip];
         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];
-      vm->stack[vm->stack_top++] = c;
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type        = FZL_TYPE_STRING,
+                          .as.s.length = c.as.string.length,
+                          .as.s.value  = c.as.string.chars};
+      }
       break;
 
-    case FZL_OPCODE_PUSHARG:
+      case FZL_OPCODE_ADD:
-      if (vm->stack_top < 1)
+        if (vm->dtop < 2)
         {
           snprintf(last_err, sizeof(last_err),
-                 "runtime error - cannot push argument: stack is empty");
+                   "runtime error - expected 2 values in stack");
+          print_err_data(vm);
           return -1;
         }
-      vm->arg_stack[vm->arg_top++] = vm->stack[--vm->stack_top];
+        fzl_value_t add1 = vm->dstack[--vm->dtop];
+        fzl_value_t add2 = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = add1.type, .as.u = add1.as.u + add2.as.u};
         break;
 
+      case FZL_OPCODE_SUB:
+        if (vm->dtop < 2)
+        {
+          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];
+        fzl_value_t sub1 = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = sub1.type, .as.u = sub1.as.u - sub2.as.u};
+        break;
+
+      case FZL_OPCODE_MUL:
+        if (vm->dtop < 2)
+        {
+          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];
+        fzl_value_t mul2 = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = mul1.type, .as.u = mul1.as.u * mul2.as.u};
+        break;
+
+      case FZL_OPCODE_DIV:
+        if (vm->dtop < 2)
+        {
+          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];
+        fzl_value_t div2 = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = div1.type, .as.u = div2.as.u / div1.as.u};
+        break;
+
+      case FZL_OPCODE_POW:
+        if (vm->dtop < 2)
+        {
+          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];
+        fzl_value_t pow1 = vm->dstack[--vm->dtop];
+
+        uint64_t pow_n     = pow1.as.u;
+        uint64_t pow_res   = pow_n;
+        uint64_t pow_times = pow2.as.u;
+        for (size_t i = 1; i < pow_times; i++)
+          pow_res *= pow_n;
+
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = pow1.type, .as.u = pow_res};
+        break;
+
+      case FZL_OPCODE_MOD:
+        if (vm->dtop < 2)
+        {
+          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];
+        fzl_value_t mod2 = vm->dstack[--vm->dtop];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = mod1.type, .as.u = mod2.as.u % mod1.as.u};
+        break;
+
+      case FZL_OPCODE_NEG:
+        if (vm->dtop < 1)
+        {
+          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];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = neg_n.type, .as.u = -neg_n.as.u};
+        break;
+
+      case FZL_OPCODE_PUSHNUM:
+      {
+        uint64_t push_n = vm->ops[++vm->ip];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_UINT, .as.u = push_n};
+        break;
+      }
+
+      case FZL_OPCODE_PUSHBOOL:
+      {
+        uint64_t push_b = vm->ops[++vm->ip];
+        vm->dstack[vm->dtop++] =
+            (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = push_b};
+        break;
+      }
+
       default:
-      snprintf(last_err, sizeof(last_err), "runtime error - unknown opcode %lu",
+        snprintf(last_err, sizeof(last_err),
-               opcode);
+                 "runtime error - unknown opcode %u", opcode);
+        print_err_data(vm);
         return -1;
     }
 
@@ -171,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)

src/vm/fzl_vm_debug.c

@@ -0,0 +1,171 @@
+#include "common/fzl_opcodes.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <vm/fzl_vm.h>
+
+void fzl_vm_print_ops(fzl_vm_t *vm)
+{
+  if (!vm)
+    return;
+
+  if (vm->ops_count < 1)
+  {
+    printf("no opcodes\n");
+    return;
+  }
+
+  for (size_t i = 0; i < vm->ops_count; i++)
+  {
+    printf("%04ld: ", i);
+
+    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);
+        break;
+      }
+
+      case FZL_OPCODE_RET:
+        printf("RET\n");
+        break;
+
+      case FZL_OPCODE_LOADCONST:
+      {
+        size_t const_n = vm->ops[++i];
+        fzl_const_t c  = vm->consts[const_n];
+        printf("LOADCONST #%lu ('%s')\n", const_n, c.as.string.chars);
+        break;
+      }
+
+      case FZL_OPCODE_CALL_BUILTIN:
+        printf("CALL_BUILTIN #%lu\n", vm->ops[++i]);
+        break;
+
+      case FZL_OPCODE_PUSHNUM:
+        printf("PUSHNUM %lu\n", vm->ops[++i]);
+        break;
+
+      case FZL_OPCODE_PUSHBOOL:
+        printf("PUSHBOOL %s\n", vm->ops[++i] ? "true" : "false");
+        break;
+
+      case FZL_OPCODE_MK_ENVTABLE:
+        printf("MK_ENVTABLE\n");
+        break;
+
+      case FZL_OPCODE_RM_ENVTABLE:
+        printf("RM_ENVTABLE\n");
+        break;
+
+      case FZL_OPCODE_STORE:
+        printf("STORE\n");
+        break;
+
+      case FZL_OPCODE_LOOKUP_ENV:
+        printf("LOOKUP_ENV\n");
+        break;
+
+      case FZL_OPCODE_WRITE:
+        printf("WRITE\n");
+        break;
+
+      case FZL_OPCODE_ADD:
+      case FZL_OPCODE_SUB:
+      case FZL_OPCODE_MUL:
+      case FZL_OPCODE_DIV:
+      case FZL_OPCODE_POW:
+      case FZL_OPCODE_MOD:
+        printf("MATH\n");
+        break;
+
+      case FZL_OPCODE_AND:
+        printf("AND\n");
+        break;
+
+      case FZL_OPCODE_OR:
+        printf("OR\n");
+        break;
+
+      case FZL_OPCODE_CMP_EQ:
+        printf("CMP_EQ\n");
+        break;
+
+      case FZL_OPCODE_CMP_NEQ:
+        printf("CMP_NEQ\n");
+        break;
+
+      case FZL_OPCODE_CMP_LT:
+        printf("CMP_LT\n");
+        break;
+
+      case FZL_OPCODE_CMP_LTEQ:
+        printf("CMP_LTEQ\n");
+        break;
+
+      case FZL_OPCODE_CMP_GT:
+        printf("CMP_GT\n");
+        break;
+
+      case FZL_OPCODE_CMP_GTEQ:
+        printf("CMP_GTEQ\n");
+        break;
+
+      case FZL_OPCODE_NOT:
+        printf("CMP_NOT\n");
+        break;
+
+      case FZL_OPCODE_NEG:
+        printf("NEG\n");
+        break;
+
+      case FZL_OPCODE_JZ:
+        printf("JZ IP: %ld\n", vm->ops[++i]);
+        break;
+
+      case FZL_OPCODE_JMP:
+        printf("JMP IP: %ld\n", vm->ops[++i]);
+        break;
+
+      default:
+        printf("<UNKNOWN>\n");
+    }
+  }
+}

src/vm/fzl_vm_env.c

@@ -0,0 +1,120 @@
+#include "vm/fzl_vm_object.h"
+#include <common/fzl_types.h>
+#include <common/fzl_value.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/fzl_vm_env.h>
+
+fzl_vm_env_t *fzl_mkenv()
+{
+  fzl_vm_env_t *env = malloc(sizeof(fzl_vm_env_t));
+  env->remainder    = 2;
+  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;
+}
+
+// Resize table if size eq to remainder
+static void resize_env_if_needed(fzl_vm_env_t *env)
+{
+  if (env->remainder > env->size)
+    return;
+
+  env->remainder *= 2;
+  env->table = realloc(env->table, env->remainder * sizeof(fzl_vm_env_entry_t));
+}
+
+bool fzl_env_lookup(fzl_vm_env_t *env, char *name, fzl_value_t *res)
+{
+  if (!env)
+    return false;
+
+  for (size_t i = 0; i < env->size; i++)
+    if (strcmp(env->table[i].name, name) == 0)
+    {
+      *res = env->table[i].value;
+      return true;
+    }
+
+  return false;
+}
+
+bool fzl_env_contains(fzl_vm_env_t *env, char *name)
+{
+  if (!env)
+    return false;
+
+  for (size_t i = 0; i < env->size; i++)
+    if (strcmp(env->table[i].name, name) == 0)
+      return true;
+
+  return false;
+}
+
+fzl_vm_env_wresult_t fzl_env_storevalue(fzl_vm_env_t *env, char *name,
+                                        fzl_value_t val)
+{
+  if (!env)
+    return FZL_VM_ENV_WRESULT_ERR;
+
+  resize_env_if_needed(env);
+  if (fzl_env_contains(env, name))
+    return FZL_VM_ENV_WRESULT_ERR_EXISTS;
+
+  env->table[env->size++] = (fzl_vm_env_entry_t){.name = name, .value = val};
+
+  return FZL_VM_ENV_WRESULT_OK;
+}
+
+fzl_vm_env_wresult_t fzl_env_writevalue(fzl_vm_env_t *env, char *name,
+                                        fzl_value_t newval)
+{
+  if (!env)
+    return FZL_VM_ENV_WRESULT_ERR;
+
+  for (size_t i = 0; i < env->size; i++)
+  {
+    if (strcmp(env->table[i].name, name) == 0)
+    {
+      env->table[i].value = newval;
+      return FZL_VM_ENV_WRESULT_OK;
+    }
+  }
+
+  return FZL_VM_ENV_WRESULT_ERR_NOT_FOUND;
+}
+
+void fzl_freeenv(fzl_vm_env_t *env)
+{
+  if (!env)
+    return;
+
+  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);
+}

src/vm/main.c

@@ -9,6 +9,7 @@ typedef struct
 {
   char *filepath;
   bool help;
+  bool debug;
 } run_args_t;
 
 void print_hint()
@@ -30,8 +31,9 @@ run_args_t *parse_args(int argc, char **argv)
   run_args_t *args = malloc(sizeof(run_args_t));
   args->filepath   = NULL;
   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;
@@ -41,10 +43,13 @@ run_args_t *parse_args(int argc, char **argv)
       args->help = true;
       return args;
     }
+    else if (strcmp(argv[i], "-d") == 0 || strcmp(argv[i], "--debug") == 0)
+      args->debug = true;
     else
     {
       printf("Error: unknown flag '%s'.\n", argv[i]);
       printf("Use 'fz --help' to read the usage\n");
+      free(args);
       return NULL;
     }
   }
@@ -53,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;
   }
 
@@ -69,6 +75,7 @@ int main(int argc, char **argv)
   else if (args->help)
   {
     print_hint();
+    free(args);
     return 0;
   }
 
@@ -76,15 +83,26 @@ int main(int argc, char **argv)
   if (!vm)
   {
     printf("Error: %s\n", fzl_vm_geterror());
+    free(args);
     return -1;
   }
 
+  if (args->debug)
+    fzl_vm_print_ops(vm);
+  else
+  {
     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;
     }
+  }
 
   free(args);
   fzl_freevm(vm);