fix: sanitizer checks fix (iteration 3 - final)

fix: sanitizer checks fix (iteration 2)
fix: sanitizer checks fix (iteration 1)
2026-10-19 20:11:48 +03:00 · 2026-10-19 19:54:11 +03:00 · 2026-10-19 19:41:39 +03:00 · 2026-10-19 18:39:40 +03:00 · 2026-10-19 17:50:31 +03:00
31 changed files with 320 additions and 800 deletions
@@ -1,8 +1,14 @@
-cmake_minimum_required(VERSION 4.3)
+cmake_minimum_required(VERSION 3.16)
 project(fz-lang
 	LANGUAGES C)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 add_compile_options(-Wall -Wextra -Werror=implicit-function-declaration)
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
 	add_compile_options(-fsanitize=address,undefined -g)
 	add_link_options(-fsanitize=address,undefined)
 endif()
 include_directories(include)
@@ -0,0 +1,6 @@
 program       := statement*
 statement     := expression
 expression    := call | string_literal
 call          := name "(" argument-list? ")"
 argument-list := string_literal ("," string_literal)*
@@ -1,43 +0,0 @@
 # Вступление
 Добро пожаловать в небольшую книжку по основам языка FZLang и спасибо, что решились попробовать этот язык программирования.
 Для начала, стоит рассказать, что это за язык и как будет идти обучение в этой "книжке".
 ## Что такое FZLang
 FZLang - это язык программирования с собственным тулчейном, включающим в себя компилятор и виртуальную машину.
 Компилятор позволяет проверить и скомпилировать исходный код программы, чтобы сохранить в переносимый файл, а виртуальная машина - выполнить программу, написанную на FZLang.
 Изначально, этот проект задумывался как самоучитель по компиляторостроению.
 Мне (Samsonium) было интересно разобрать:
 - Почему между компилятором и интерпретатором есть значимая разница?
 - Как программа, под названием "компилятор" понимает, что я хочу сделать?
 - Как устроено исполнение скомпилированной программы? Да и как, вообще, происходит процесс "перевода" с человеческого на машинный?
 Я занимаюсь программированием уже более 10 лет, но за всё время так и не удосужился об этом разузнать!
 Поэтому, этот проект был рождён как поле для экспериментов, разрабатывая который я стану лучше понимать устройство того, на чём строится весь мир программистов.
 Однако, по ходу разработки у языка стала появлятся своя форма, а также философия.
 Сейчас, я бы описал философию языка так: "быть удобным, как инструмент, но всегда стараться оставаться предсказуемым".
 Полагаю, любое комьюнити желает своему языку того же, но мне это помогло сделать определённый выбор в ключевых точках развития.
 ### Как в FZLang устроена работа с памятью
 Изначально вопрос появился после внедрения стеков виртуальной машины, и звучал он так: "сборщик мусора или что-то другое?".
 Изучить работу сборщика было, конечно, интересно.
 Однако мне, человеку, выбравшему Java как первый язык, была знакома его "тяжесть" и "скорость" работы.
 Конечно же, отдельное "спасибо" за это можно сказать его сборщику мусора.
 Поэтому, вместо GC я решил посмотреть в сторону RAII и, в итоге, получил хорошую формулу гуляния объекта в программе:
 если объект подан как аргумент, то происходит "заимствование" его во вложенное окружение, и если объект возвращается, то происходит перемещение объекта в родительское окружение.
 Такой подход позволяет не делать GC, а ещё, что самое важное, получить детерминированное время жизни объекта, а значит, детерминированную память (настолько, насколько это возможно).
 Короче говоря, FZLang обзавёлся scope-based RAII.
 ---
 Далее: [Начало работы](./01_getting-started.md)
@@ -1,46 +0,0 @@
 # Начало работы
 Для того, чтобы начать работу с FZLang, достаточно установить себе на компьютер два исполяемых файла:
 - `fzc` - компилятор
 - `fz` - виртуальная машина
 Для того, чтобы скомпилировать программу, достаточно выполнить программу `fzc`, указав в качестве аргументов пути к файлам с исходным кодом.
 Если программа успешно скомпилировалась, то её можно запустить через программу `fz`, также указав путь скомпилированному файлу.
 Без указания компилятору пути к выходному файлу, скомпилированная программа будет сохранена как `a.fzb`.
 ## Настройки компилятора
 Чтобы посмотреть о доступных настройках компилятора, выполните `fzc --help` (или `fzc -h`).
 На данный момент, справка выглядит так: 
 ```
 Usage: fzc [flags] <sources...>
 Available flags:
        -h      --help          Print help
        -v      --verbose       Display compilation info (tokens, AST, consts table, etc)
        -V      --version       Print compiler version
        -o      --out           Set compiled file name
 ```
 Флаг `-h` (`--help`) просто выводит ту же справку. Флаги `-v` / `--verbose` делает подробный вывод компиляции:
 - Какие лексемы были прочитаны;
 - Какое синтаксическое дерево было собрано;
 - Какие значения были записаны в таблицу констант;
 - Какие опкоды были записаны в программу.
 Флаги `-V` / `--version` выводят версию компилятора. Флаги `-o`, `--out` позволяют задать путь выходного файла.
 ## Настройки виртуальной машины
 У виртуальной машины есть всего два флага: `--help` (`-h`) и `-d`.
 - `--help` (или `-h`) выводит справку;
 - `-d <путь к файлу>` выводит список опкодов с нумерацией. С помощью этого флага вы можете посмотреть, как вашу программу будет читать ВМ.
 ---
 Далее: [Основы и типы](./02_basics-and-types.md)
 Назад: [Вступление](./00_introduction.md)
@@ -1,53 +0,0 @@
 # Основы и типы
 В этой главе разберём выражения, переменные и значения FZLang.
 Исходный код хранится в файлах с расширением .fzs, а каждая инструкция обычно заканчивается точкой с запятой.
 ## Литералы
 Числа записываются последовательностью десятичных цифр.
 Строки заключаются в одинарные или двойные кавычки, булевы значения — `true` и `false`, пустое значение для объектов — `null`.
 ```
 int answer = 42;
 str greeting = "hello";
 bool enabled = true;
 ```
 ## Объявление и присваивание
 Тип указывается перед именем переменной. Инициализация необязательна:
 ```
 uint work_it = 21 * 2 ^ 2;
 int make_it = 10;
 u64 do_it;
 do_it = 15;
 ```
 Поддерживаются машинные `int` и `uint`, знаковые `i8`, `i16`, `i32`, `i64`, беззнаковые `u8`, `u16`, `u32`, `u64`, а также `str`, `char` и `bool`.
 Имена классов используются как типы объектов.
 ## Арифметика и логика
 Доступны операции +, -, *, /, %, ^, сравнения ==, !=, <, <=, >, >= и логические операции &&, ||, !.
 Порядок разбора: унарные операции, степень, умножение/деление/остаток, сложение/вычитание, сравнения, &&, затем ||.
 Скобки меняют порядок вычисления.
 Строки поддерживают == и !=, объекты сравниваются по идентичности экземпляра.
 Несовместимые типы отклоняются компилятором.
 ## Комментарии
 Однострочный комментарий начинается с // и продолжается до конца строки.
 ```
 // Этот текст игнорируется компилятором
 printline("Комментарий пропущен");
 ```
 ---
 Далее: [Управление потоком](./03_control-flow.md)
 Назад: [Начало работы](./01_getting-started.md)
@@ -1,43 +0,0 @@
 # Управление потоком
 FZLang поддерживает условные конструкции и отдельные блоки кода.
 Условия записываются в круглых скобках, тело может быть одной инструкцией или блоком в фигурных скобках.
 ## Условие if
 ```
 if (2 + 2 >= 4)
  printline("two plus two is four");
 else
 {
  printline("unexpected result");
  exit(1);
 }
 ```
 Ветка `else if` является обычным `else`, за которым следует новый `if`.
 Условие вычисляется, после чего ВМ переходит в одну из веток; обычно это булево значение или результат сравнения.
 ## Блоки
 Фигурные скобки создают отдельное окружение:
 ```
 {
  int local = 10;
  printline(local);
 }
 ```
 После выхода из блока его окружение уничтожается.
 Локальные имена не должны использоваться за пределами блока.
 ## Ограничения
 В текущей реализации нет циклов while или for. Повторяющееся вычисление выражается рекурсивными функциями.
 ---
 Далее: [Функции и рекурсия](./04_functions-and-recursion.md)
 Назад: [Основы и типы](./02_basics-and-types.md)
@@ -1,44 +0,0 @@
 # Функции и рекурсия
 Функция объявляется ключевым словом `fn`, именем, списком типизированных аргументов и, если функция возвращает значение, типом результата.
 ```
 fn sum(uint a, uint b) uint
 {
  return a + b;
 }
 ```
 Если функция ничего не возвращает, тип после закрывающей скобки можно опустить.
 Вызов записывается как `name(arg1, arg2)`, аргументы передаются в порядке объявления.
 ## Возврат
 return завершает текущую функцию.
 Возвращаемое выражение должно быть совместимо с объявленным типом.
 Пустой return; используется в функции без результата.
 Возврат вне функции — ошибка компиляции.
 ## Рекурсия
 Функция может вызывать саму себя:
 ```
 fn factorial(uint n) uint
 {
  if (n <= 1)
    return 1;
  return n * factorial(n - 1);
 }
 ```
 Каждый вызов получает собственное окружение.
 ВМ хранит адрес возврата в стеке вызовов, а локальные значения — в стеке окружений.
 При возврате объекта компилятор переносит его владение в родительское окружение.
 ---
 Далее: [Классы и объекты](./05_classes-and-objects.md)
 Назад: [Управление потоком](./03_control-flow.md)
@@ -1,46 +0,0 @@
 # Классы и объекты
 Класс описывается блоком с полями и методами:
 ```
 class Point
 {
  int x;
  int y;
  fn move(int dx, int dy)
  {
    this.x = this.x + dx;
    this.y = this.y + dy;
  }
 }
 ```
 Методы обращаются к полям текущего экземпляра через обязательное имя `this`.
 ## Создание экземпляра
 Экземпляр создаётся выражением `new ClassName`:
 ```
 Point point = new Point;
 point.x = 1;
 point.y = 2;
 point.move(9, 8);
 ```
 Объект выделяется с количеством слотов, равным числу полей класса.
 Поля читаются и изменяются через точку.
 Поддерживаются цепочки вроде `list.next.sum()`.
 Имя класса выступает типом объекта.
 Переменная может содержать `null`, а объекты одного класса совместимы между собой.
 Сравнение == и != проверяет идентичность экземпляра, а не содержимое полей.
 Неизвестный класс или поле приводит к ошибке компиляции.
 ---
 Далее: [Модель памяти](./06_memory-model.md)
 Назад: [Функции и рекурсия](./04_functions-and-recursion.md)
@@ -1,36 +0,0 @@
 # Модель памяти
 FZLang использует scope-based RAII: объект принадлежит окружению, в котором создан, и освобождается при уничтожении этого окружения.
 Отдельного сборщика мусора нет.
 ## Окружения
 Глобальная программа, функция и каждый блок получают окружение.
 В нём хранятся имена и значения переменных.
 При поиске имени VM проверяет текущее окружение, затем внешние.
 После return локальное окружение функции закрывается.
 Возвращаемый объект переносится в родительское окружение, чтобы пережить этот момент.
 ## Владение объектом
 Передача объекта во вложенный вызов позволяет использовать его во внутреннем окружении.
 Операция `ESCAPE_OBJECT` переносит возвращаемый объект и его дочерние объекты наружу.
 ```
 fn make() Animal
 {
  Animal result = new Animal;
  return result;
 }
 ```
 Числа, булевы значения и строки хранятся как значения контейнера ВМ.
 Объектное значение содержит указатель на структуру экземпляра, а поля занимают числовые слоты класса.
 Объект не следует использовать после завершения окружения, которому он принадлежал.
 Возвращайте его из функции или храните в объекте/окружении с большим временем жизни.
 ---
 Назад: [Классы и объекты](./05_classes-and-objects.md)
@@ -1,21 +0,0 @@
 # Размещение объектов
 Экземпляр класса во время исполнения представлен структурой объекта с массивом значений полей:
 ```
 typedef struct
 {
  fzl_value_t *values;
  size_t values_count;
 } fzl_vm_object_t;
 ```
 Поля получают последовательные индексы в порядке объявления.
 Таблица класса хранит имя поля, тип и `slot_index`.
 Поэтому `object.field` компилируется в `GET_FIELD` или `SET_FIELD` с числовым индексом.
 Выражение `new ClassName` проверяет наличие класса и генерирует `ALLOC_OBJECT N`, где `N` — число полей.
 Сравнение объектов проверяет указатели.
 При уничтожении окружения освобождаются принадлежащие ему объекты и массивы их значений.
 При возврате объекта из вложенного окружения `ESCAPE_OBJECT` переносит владение в родительское окружение.
@@ -1,119 +0,0 @@
 # Опкоды
 Программы, написанные на FZLang, исполняются с помощью виртуальной машины, входящей в тулчейн FZLang и компилирующейся в паре с компилятором.
 Компилятор FZC может выпускать следующие опкоды, которые понимает и исполняет ВМ:
 ## Загрузка данных и работа со стеком
 Коды: `0xF00001`..`0xF00004`
 | Номер    | Название                | Назначение                      | Аргумент              |
 | -------- | ----------------------- | ------------------------------- | --------------------- |
 | 0xF00001 | FZL_OPCODE_LOADCONST    | Загрузить константу `N` на стек | `N` - номер константы |
 | 0xF00002 | FZL_OPCODE_CALL_BUILTIN | Вызвать встроенную функцию `N`  | `N` - номер функции   |
 | 0xF00003 | FZL_OPCODE_PUSHNUM      | Поместить на стек число `N`     | `N` - значение        |
 | 0xF00004 | FZL_OPCODE_PUSHBOOL     | Поместить на стек булеву `B`    | `B` - значение        |
 ## Управление контекстом и окружением
 Коды: `0xF10001`..`0xF10005`
 | Номер    | Название               | Назначение                                                          |
 | -------- | ---------------------- | ------------------------------------------------------------------- |
 | 0xF10001 | FZL_OPCODE_MK_ENVTABLE | Создать новое окружение                                             |
 | 0xF10002 | FZL_OPCODE_RM_ENVTABLE | Уничтожить окружение                                                |
 | 0xF10003 | FZL_OPCODE_STORE       | Создать в окружении имя, лежащее на вершине стека                   |
 | 0xF10004 | FZL_OPCODE_LOOKUP_ENV  | Достать из стека имя, найти в окружении и положить на стек значение |
 | 0xF10005 | FZL_OPCODE_WRITE       | Достать со стека имя и значение, и записать в окружение             |
 ## Управление потоком
 Коды: `0xF20001`..`0xF20002`
 | Номер    | Название       | Назначение                                                        | Аргумент                 |
 | -------- | -------------- | ----------------------------------------------------------------- | ------------------------ |
 | 0xF20001 | FZL_OPCODE_JMP | Прыгнуть на адрес `IP`                                            | `IP` - адрес-цель прыжка |
 | 0xF20002 | FZL_OPCODE_JZ  | Прыгнуть на адрес `IP`, если значение на вершине стека равно нулю | `IP` - адрес-цель прыжка |
 ## Вызов функций
 Коды: `0xF30001`..`0xF30002`
 | Номер    | Название        | Назначение                                                        |
 | -------- | --------------- | ----------------------------------------------------------------- |
 | 0xF30001 | FZL_OPCODE_CALL | Положить на стек вызовов текущий адрес и перейти к началу функции |
 | 0xF30002 | FZL_OPCODE_RET  | Снять со стека вызовов последний адрес и перейти к нему           |
 ## Работа с объектами
 Коды: `0xFA0001`..`0xFA0005`
 | Номер    | Название                 | Назначение                                                                       | Аргумент              |
 | -------- | ------------------------ | -------------------------------------------------------------------------------- | --------------------- |
 | 0xFA0001 | FZL_OPCODE_ALLOC_OBJECT  | Аллоцировать объект под `N` значений и поместить его на стек                     | `N` - кол-во значений |
 | 0xFA0002 | FZL_OPCODE_GET_FIELD     | Снять со стека ссылку на объект и получить значение поля `N`                     | `N` - номер поля      |
 | 0xFA0003 | FZL_OPCODE_SET_FIELD     | Снять со стека ссылку на объект и значение, а затем записать значение в поле `N` | `N` - номер поля      |
 | 0xFA0004 | FZL_OPCODE_ESCAPE_OBJECT | Перенести объект (в т.ч. дочерние ему) в родительское окружение                  | отсутствует           |
 ## Арифметические операции
 Коды: `0xA00001`..`0xA00007`
 | Номер    | Название       | Назначение                                                                              |
 | -------- | -------------- | --------------------------------------------------------------------------------------- |
 | 0xA00001 | FZL_OPCODE_ADD | Снять два числа со стека и сложить их, положив результат на стек                        |
 | 0xA00002 | FZL_OPCODE_SUB | Снять два числа со стека и вычесть первое от второго, положив результат на стек         |
 | 0xA00003 | FZL_OPCODE_MUL | Снять два числа со стека и переменожить их, положив результат на стек                   |
 | 0xA00004 | FZL_OPCODE_DIV | Снять два числа со стека и поделить первое на второе, положив результат на стек         |
 | 0xA00005 | FZL_OPCODE_POW | Снять два числа со стека и возвести второе в степерь первого, положив результат на стек |
 | 0xA00006 | FZL_OPCODE_MOD | Снять два числа со стека и положить на стек остаток от деления второго на первое        |
 | 0xA00007 | FZL_OPCODE_NEG | Снять число со стека, инвертировать, и положить обратно на стек                         |
 ## Сравнение чисел
 Коды: `0xB00001`..`0xB00006`
 | Номер    | Название            | Назначение                                                                                                   |
 | -------- | ------------------- | ------------------------------------------------------------------------------------------------------------ |
 | 0xB00001 | FZL_OPCODE_CMP_EQ   | Снять два числа со стека, проверить на равенство и положить на стек результат                                |
 | 0xB00002 | FZL_OPCODE_CMP_NEQ  | Снять два числа со стека, проверить на неравенство и сохранить результат на стеке                            |
 | 0xB00003 | FZL_OPCODE_CMP_LT   | Снять два числа со стека, проверить, что второе меньше первого, и затем положить результат на стек           |
 | 0xB00004 | FZL_OPCODE_CMP_LTEQ | Снять два числа со стека, проверить, что второе меньше или равно первому, и затем положить результат на стек |
 | 0xB00005 | FZL_OPCODE_CMP_GT   | Снять два числа со стека, проверить, что второе больше первого, и затем положить результат на стек           |
 | 0xB00006 | FZL_OPCODE_CMP_GTEQ | Снять два числа со стека, проверить, что второе больше или равно первому, и затем положить результат на стек |
 ## Сравнение строк
 Коды: `0xB10001`..`0xB10002`
 | Номер    | Название               | Назначение                                                                     |
 | -------- | ---------------------- | ------------------------------------------------------------------------------ |
 | 0xB10001 | FZL_OPCODE_CMP_EQ_STR  | Снять две строки со стека, сравнить на равенство, положить результат на стек   |
 | 0xB10002 | FZL_OPCODE_CMP_NEQ_STR | Снять две строки со стека, сравнить на неравенство, положить результат на стек |
 ## Сравнение объектов
 Коды: `0xB20001`..`0xB20002`
 | Номер    | Название               | Назначение                                                                      |
 | -------- | ---------------------- | ------------------------------------------------------------------------------- |
 | 0xB20001 | FZL_OPCODE_CMP_EQ_OBJ  | Снять два объекта со стека, сравнить на равенство, положить результат на стек   |
 | 0xB20002 | FZL_OPCODE_CMP_NEQ_OBJ | Снять два объекта со стека, сравнить на неравенство, положить результат на стек |
 ## Бинарные логические операции
 Коды: `0xC00001`..`0xC00002`
 | Номер    | Название       | Назначение                                                               |
 | -------- | -------------- | ------------------------------------------------------------------------ |
 | 0xC00001 | FZL_OPCODE_AND | Взять два значения со стека и положить на стек результат логического И   |
 | 0xC00002 | FZL_OPCODE_OR  | Взять два значения со стека и положить на стек результат логического ИЛИ |
 ## Унарные логические операции
 Коды: `0xD00001`
 | Номер    | Название       | Назначение                                                         |
 | -------- | -------------- | ------------------------------------------------------------------ |
 | 0xD00001 | FZL_OPCODE_NOT | Взять значение со стека и положить инвертированный булев результат |
@@ -1,24 +0,0 @@
 # Стеки виртуальной машины
 ВМ использует три фиксированных стека по 256 элементов.
 ## Стек данных
 `dstack` хранит значения `fzl_value_t`: числа, строки, булевы значения, ссылки на объекты и null.
 `PUSHNUM`, `PUSHBOOL` и `LOADCONST` помещают значения на стек.
 Арифметические и логические операции снимают операнды и кладут результат обратно.
 ## Стек вызовов
 `cstack` хранит адреса возврата.
 `CALL` сохраняет текущий адрес и переходит к функции,
 `RET` снимает последний адрес.
 Рекурсивные вызовы используют отдельные записи.
 ## Стек окружений
 `estack` хранит таблицы имён и владельцев объектов.
 `MK_ENVTABLE` создаёт окружение, `RM_ENVTABLE` уничтожает его, `STORE` добавляет имя, `LOOKUP_ENV` ищет значение, `WRITE` изменяет переменную.
 `ESCAPE_OBJECT` переносит возвращаемый объект перед закрытием окружения.
 Запуск `fz -d program.fzb` печатает декодированную последовательность опкодов и аргументов.
@@ -1,31 +0,0 @@
 # Философия языка
 Язык FZLang преследует две цели при разработке: "быть удобным, как инструмент, но всегда оставаться предсказуемым".
 Вот, какими путями язык пытается достичь этой философии:
 ## В отношении к памяти и ресурсам
 В средах с GC программист точно не знает, в какой момент сборщик мусора решит произвести очистку:
 объект может висеть секундами после завершения метода.
 А в момент очистки рантайм может устроить микропаузу, что критично для аудио, игр, сети или встроенных систем.
 В модели scope-based RAII, которая используется в том числе в FZLang, память детерминирована.
 Любой объект имеет область, которая им владеет, а как только область уничтожается - объект уничтожается вместе с ней.
 Время отклика таком подходе равное и предсказуемое.
 Ещё один плюс, который предоставляет модель scope-based RAII - это работа с ресурсами (сокеты, файлы).
 Проблема освобождения ресурсов решается чистой семантикой области видимости: умирает скоуп - очищается всё, что к нему привязано.
 И последним аргументом в сторону scope-based RAII стало отстутствие оверхеда на рантайм.
 Полноценному GC для работы нужны карты памяти, фоновые потоки, барьеры чтения и записи.
 В FZLang виртуальная машина весит очень мало, а вся память освобождается по ходу чтения инструкций.
 ## В отношении синтаксиса
 Язык FZLang намеренно не упрощается некоторые детали синтаксиса.
 Например, при обращении к экземпляру класса в его методах, использование `this` является обязательным, как и указание типов при декларациях, - это строгая часть.
 Однако, объявление функции без возвращаемого типа позволяет опускать тип, так как писать на месте типа постоянно `void` было бы избыточно.
 Таким образом, FZLang старается балансировать между синтаксисом, позволяющим оставаться языку детерминированным и упрощениями, которые действительно уместны.
@@ -1,19 +0,0 @@
 # Интерфейс компилятора
 Компилятор называется `fzc`.
 Он принимает исходные файлы `.fzs` и создаёт бинарный файл `.fzb`.
 ```
 fzc [flags] <sources...>
 ```
 | Флаг          | Назначение                                     |
 | ------------- | ---------------------------------------------- |
 | -h, --help    | Показать справку                               |
 | -v, --verbose | Вывести токены, AST, таблицу констант и опкоды |
 | -V, --version | Показать версию                                |
 | -o, --out     | Задать имя выходного файла                     |
 Если `-o` не задан, результат записывается в `a.fzb`. Пример: `fzc -v -o hello.fzb exl/hw.fzs`.
 VM запускается командой `fz [flags] <file path>`. Флаг `-d` или `--debug` печатает опкоды, не выполняя программу.
@@ -1,33 +0,0 @@
 # Грамматика (EBNF)
 Упрощённая грамматика текущего парсера:
 ```
 program        = { statement } ;
 statement      = class | function | if | block | return | expression ";" ;
 block          = "{" { statement } "}" ;
 class          = "class" name "{" { declaration | function } "}" ;
 function       = "fn" name "(" [ parameters ] ")" [ type-name ] statement ;
 parameters     = parameter { "," parameter } ;
 parameter      = type-name name ;
 return         = "return" [ expression ] ";" ;
 if             = "if" "(" expression ")" statement [ "else" statement ] ;
 expression     = assignment ;
 assignment     = new-expression [ "=" assignment ] ;
 new-expression = logical-or | "new" name ;
 logical-or     = logical-and { "||" logical-and } ;
 logical-and    = comparison { "&&" comparison } ;
 comparison     = term { compare-op term } ;
 term           = factor { ( "+" | "-" ) factor } ;
 factor         = power { ( "*" | "/" | "%" ) power } ;
 power          = unary [ "^" unary ] ;
 unary          = ( "+" | "-" | "!" ) unary | postfix ;
 postfix        = primary { call | member } ;
 call           = "(" [ expression { "," expression } ] ")" ;
 member         = "." name ;
 primary        = literal | declaration | name | "(" expression ")" ;
 declaration    = type-name name ;
 type-name      = builtin-type | name ;
 ```
 `literal` включает строковый, числовой, булев и `null` литералы. Комментарии `// ...` и пробельные символы между токенами игнорируются.
@@ -1,17 +0,0 @@
 # Операторы
 | Оператор             | Назначение                             |
 | -------------------- | -------------------------------------- |
 | +, -                 | Сложение/вычитание, унарные плюс/минус |
 | *, /, %              | Умножение, деление, остаток            |
 | ^                    | Возведение в степень                   |
 | ==, !=, <, <=, >, >= | Сравнение                              |
 | !                    | Логическое отрицание                   |
 | &&, ||               | Логические И и ИЛИ                     |
 | =                    | Присваивание                           |
 | .                    | Доступ к полю и методу                 |
 Для строк и объектов доступны только `==` и `!=`.
 Ключевое слово `new` создаёт экземпляр класса: `new Point`.
 Приоритет от большего к меньшему: унарные операции; ^; *, /, %; +, -; сравнения; &&; ||; =. Скобки имеют высший приоритет.
@@ -1,22 +0,0 @@
 # Система типов
 | Типы              | Значение                                 |
 | ----------------- | ---------------------------------------- |
 | int, uint         | Целое машинного размера                  |
 | i8, i16, i32, i64 | Знаковые целые фиксированного размера    |
 | u8, u16, u32, u64 | Беззнаковые целые фиксированного размера |
 | str               | Строка                                   |
 | char              | Символ                                   |
 | bool              | Булево значение                          |
 | ClassName         | Экземпляр пользовательского класса       |
 Также существует `null`, применимое к объектным значениям.
 Тип указывается при объявлении переменной, поля и аргумента функции.
 Объект совместим с объектом того же класса или с `null`.
 Объекты разных классов несовместимы.
 Строки поддерживают `==` и `!=`, объекты сравниваются по ссылке.
 Поля класса имеют объявленные типы и последовательные слоты.
 Для функции тип результата указывается после списка параметров.
 Для функции без результата его можно опустить.
@@ -1,30 +0,0 @@
 # Встроенные функции
 Встроенные функции распознаются компилятором по имени и исполняются ВМ напрямую.
 ## printline
 Выводит аргумент в стандартный вывод и добавляет перевод строки:
 ```
 printline("hello, world");
 printline(42);
 ```
 Вызов без аргументов считается ошибкой компиляции.
 Функция используется для строк, чисел, булевых значений и объектов.
 ## exit
 Завершает программу с указанным кодом возврата:
 ```
 if (failed)
 {
  printline("Test failed");
  exit(1);
 }
 ```
 Код передаётся одним аргументом.
 Ненулевой код обычно означает ошибку.
@@ -4,12 +4,12 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 // Constant types
 typedef enum
 {
  FZL_CONSTTYPE_STRING,
  FZL_CONSTTYPE_NUMBER
 } fzl_consttype_t;
 // Constant descriptor
@@ -34,7 +34,7 @@ typedef struct
 typedef struct
 {
-  size_t pool_index;
+  ssize_t pool_index;
 } fzl_const_hash_slot_t;
 // Constant pool descriptor
@@ -53,13 +53,13 @@ typedef struct
 bool fzl_consts_equal(fzl_const_t a, fzl_const_t b);
 // Get hash of specified constant
-static uint32_t fzl_hash_const(fzl_const_t c);
+uint32_t fzl_hash_const(fzl_const_t c);
 // Allocate constants hash pool
 fzl_const_hash_pool_t *fzl_mkconstpool();
 // Resize the hash table
-static void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool);
+void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool);
 // Push constant. Returns unique index
 size_t fzl_consts_pool_add(fzl_const_hash_pool_t *pool, fzl_const_t c);
@@ -27,7 +27,6 @@ void print_node(fzl_node_t *node, int level)
  if (!node)
    return;
  size_t lvllen = print_level(levelbuf, level);
  strcpy(printbuf, levelbuf);
  switch (node->type)
@@ -9,6 +9,24 @@
 char plast_err[256];
 fzl_token_t *last_known_tok = NULL;
 fzl_token_t null_tok = {
    .type        = FZL_TOKTYPE_TYPE,
    .filename    = "",
    .ln          = 0,
    .cn          = 0,
    .store_value = false,
    .value       = "null",
    .value_sz    = 4,
 };
 fzl_token_t this_tok = {.type        = FZL_TOKTYPE_NAME,
                        .filename    = "",
                        .ln          = 0,
                        .cn          = 0,
                        .store_value = false,
                        .value       = "this",
                        .value_sz    = 4};
 fzl_parser_t *fzl_mkparser(fzl_reader_ll_t *first)
 {
  if (!first)
@@ -35,6 +53,7 @@ fzl_parser_t *fzl_mkparser(fzl_reader_ll_t *first)
 fzl_node_t *fzl_mknode(fzl_nodetype_t type, fzl_token_t *token)
 {
  fzl_node_t *node = malloc(sizeof(fzl_node_t));
  memset(node, 0, sizeof(fzl_node_t));
  if (!node)
    return NULL;
@@ -56,19 +75,6 @@ static fzl_token_t *peek(fzl_parser_t *parser)
  return parser->cursor->token;
 }
 // Get token at (cursor + 1)
 static fzl_token_t *next(fzl_parser_t *parser)
 {
  if (!parser || !parser->cursor)
    return NULL;
  fzl_reader_ll_t *next = parser->cursor->next;
  if (!next)
    return NULL;
  return next->token;
 }
 // Consume token at cursor and move to the next
 static fzl_token_t *consume(fzl_parser_t *parser)
 {
@@ -204,8 +210,7 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
  if (!parser)
    return NULL;
-  fzl_node_t *left  = parse_primary(parser);
+  fzl_node_t *left = parse_primary(parser);
  fzl_node_t *right = NULL;
  if (!left)
  {
@@ -240,7 +245,7 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
          if (args_capacity <= args_count)
          {
            args_capacity *= 2;
-            args = realloc(args, args_capacity * sizeof(fzl_node_t));
+            args = realloc(args, args_capacity * sizeof(fzl_node_t *));
          }
          args[args_count] = arg;
@@ -714,19 +719,27 @@ fzl_node_t *parse_class(fzl_parser_t *parser)
        }
      }
-      fzl_node_t **new_args = realloc(node->fn.args, ++node->fn.args_count);
+      fzl_node_t **new_args = realloc(node->fn.args, (++node->fn.args_count) *
-      memcpy(&new_args[1], new_args,
+                                                         sizeof(fzl_node_t *));
-             (node->fn.args_count - 1) * sizeof(fzl_node_t *));
+      if (!new_args)
      {
        snprintf(plast_err, sizeof(plast_err),
                 "failed to reallocate method args list");
        free(fields);
        return NULL;
      }
-      fzl_token_t *this_tok =
+      if (node->fn.args_count > 1)
-          fzl_mktoken(FZL_TOKTYPE_NAME, node->fn.name->ln, node->fn.name->cn,
+        memmove(&new_args[1], new_args,
-                      "this", 4, node->fn.name->filename);
+                (node->fn.args_count - 1) * sizeof(fzl_node_t *));
-      fzl_node_t *this_id      = fzl_mknode(FZL_NODETYPE_IDENTIFIER, this_tok);
+
      fzl_node_t *this_id      = fzl_mknode(FZL_NODETYPE_IDENTIFIER, &this_tok);
      fzl_node_t *this_dec     = fzl_mknode(FZL_NODETYPE_DECLARATION, name);
      this_dec->var.type       = name;
      this_dec->var.identifier = this_id;
      new_args[0]       = this_dec;
      node->fn.args     = new_args;
      methods[mcount++] = node;
    }
    else
@@ -766,7 +779,15 @@ fzl_node_t *parse_function(fzl_parser_t *parser)
  if (!parser)
    return NULL;
-  fzl_token_t *fn   = consume(parser);
+  fzl_token_t *fn = consume(parser);
  if (fn->type != FZL_TOKTYPE_FUNCTION)
  {
    snprintf(plast_err, sizeof(plast_err),
             "'%s': expected keyword 'fn' at %ld:%ld", last_known_tok->filename,
             last_known_tok->ln, last_known_tok->cn);
    return NULL;
  }
  fzl_token_t *name = consume(parser);
  if (!name || name->type != FZL_TOKTYPE_NAME)
  {
@@ -820,8 +841,7 @@ fzl_node_t *parse_function(fzl_parser_t *parser)
    type = consume(parser);
  if (!type)
-    type = fzl_mktoken(FZL_TOKTYPE_TYPE, last_known_tok->ln, last_known_tok->cn,
+    type = &null_tok;
                       "null", 4, last_known_tok->filename);
  if (!is(parser, FZL_TOKTYPE_LBRACE))
  {
@@ -959,6 +979,9 @@ fzl_node_t *parse_block(fzl_parser_t *parser)
 // Statement parsing
 fzl_node_t *parse_statement(fzl_parser_t *parser)
 {
  if (!peek(parser))
    return NULL;
  fzl_node_t *res = NULL;
  if (is(parser, FZL_TOKTYPE_CLASS))
@@ -990,6 +1013,9 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
 // Internal parsing entry point
 fzl_node_t *parse_program(fzl_parser_t *parser)
 {
  if (!peek(parser))
    return NULL;
  fzl_node_t *first = NULL;
  fzl_node_t *last  = NULL;
  fzl_node_t *node  = NULL;
@@ -1023,6 +1049,8 @@ fzl_node_t *parse_program(fzl_parser_t *parser)
 // Parse tokens and build AST
 int fzl_parse(fzl_parser_t *parser)
 {
  last_known_tok = NULL;
  fzl_node_t *ast = parse_program(parser);
  if (!ast)
    return -1;
@@ -1049,80 +1077,119 @@ void fzl_freeast(fzl_node_t *root)
  while (root)
  {
-    if (root->type == FZL_NODETYPE_BLOCK)
+    switch (root->type)
    {
-      if (root->list.entries)
+      case FZL_NODETYPE_IDENTIFIER:
-      {
+      case FZL_NODETYPE_LITERAL:
-        for (size_t i = 0; i < root->list.entry_count; i++)
+        break;
          if (root->list.entries[i])
            fzl_freeast(root->list.entries[i]);
-        free(root->list.entries);
+      case FZL_NODETYPE_BLOCK:
-      }
+        if (root->list.entries)
-    }
+        {
-    else if (root->type == FZL_NODETYPE_CALL)
+          for (size_t i = 0; i < root->list.entry_count; i++)
-    {
+            if (root->list.entries[i])
-      if (root->call.args_count)
+              fzl_freeast(root->list.entries[i]);
      {
        for (size_t i = 0; i < root->call.args_count; i++)
          if (root->call.args[i])
            fzl_freeast(root->call.args[i]);
-        free(root->call.args);
+          free(root->list.entries);
-      }
+        }
-    }
+        break;
    else if (root->type == FZL_NODETYPE_ADD || root->type == FZL_NODETYPE_SUB ||
             root->type == FZL_NODETYPE_MUL || root->type == FZL_NODETYPE_DIV ||
             root->type == FZL_NODETYPE_POW || root->type == FZL_NODETYPE_MOD)
    {
      if (root->binary_op.left)
        fzl_freeast(root->binary_op.left);
      if (root->binary_op.right)
        fzl_freeast(root->binary_op.right);
    }
    else if (root->type == FZL_NODETYPE_UNARY_PLUS ||
             root->type == FZL_NODETYPE_UNARY_MINUS)
    {
      if (root->unary_op.operand)
        fzl_freeast(root->unary_op.operand);
    }
    else if (root->type == FZL_NODETYPE_FUNCTION)
    {
      if (root->fn.args_count)
        for (size_t i = 0; i < root->fn.args_count; i++)
          fzl_freenode(root->fn.args[i]);
      free(root->fn.args);
      fzl_freenode(root->fn.body);
    }
    else if (root->type == FZL_NODETYPE_RETURN)
    {
      if (root->ret.value)
        fzl_freenode(root->ret.value);
    }
    else if (root->type == FZL_NODETYPE_CLASS)
    {
      if (root->class.fields_count)
        for (size_t i = 0; i < root->class.fields_count; i++)
          fzl_freenode(root->class.fields[i]);
      free(root->class.fields);
-      if (root->class.methods_count)
+      case FZL_NODETYPE_CALL:
-        for (size_t i = 0; i < root->class.methods_count; i++)
+        if (root->call.callee)
-          fzl_freenode(root->class.methods[i]);
+          fzl_freeast(root->call.callee);
-      free(root->class.methods);
+
-    }
+        if (root->call.args_count)
-    else if (root->type == FZL_NODETYPE_CONSTRUCT)
+        {
-    {
+          for (size_t i = 0; i < root->call.args_count; i++)
-      fzl_freenode(root->construct.name);
+            if (root->call.args[i])
-    }
+              fzl_freeast(root->call.args[i]);
-    else if (root->type == FZL_NODETYPE_FIELD)
+        }
-    {
+        if (root->call.args)
-      fzl_freenode(root->memb.field);
+          free(root->call.args);
-      fzl_freenode(root->memb.parent);
+        break;
      case FZL_NODETYPE_CONDITIONAL:
        if (root->cond.condition)
          fzl_freeast(root->cond.condition);
        if (root->cond.true_block)
          fzl_freeast(root->cond.true_block);
        if (root->cond.else_block)
          fzl_freeast(root->cond.else_block);
        break;
      case FZL_NODETYPE_ADD:
      case FZL_NODETYPE_SUB:
      case FZL_NODETYPE_MUL:
      case FZL_NODETYPE_DIV:
      case FZL_NODETYPE_POW:
      case FZL_NODETYPE_MOD:
      case FZL_NODETYPE_OR:
      case FZL_NODETYPE_AND:
      case FZL_NODETYPE_EQUAL:
      case FZL_NODETYPE_NEQUAL:
      case FZL_NODETYPE_LESS:
      case FZL_NODETYPE_LESS_EQUAL:
      case FZL_NODETYPE_GREATER:
      case FZL_NODETYPE_GREATER_EQUAL:
      case FZL_NODETYPE_ASSIGN:
        if (root->binary_op.left)
          fzl_freeast(root->binary_op.left);
        if (root->binary_op.right)
          fzl_freeast(root->binary_op.right);
        break;
      case FZL_NODETYPE_UNARY_PLUS:
      case FZL_NODETYPE_UNARY_MINUS:
      case FZL_NODETYPE_NOT:
        if (root->unary_op.operand)
          fzl_freeast(root->unary_op.operand);
        break;
      case FZL_NODETYPE_FUNCTION:
        if (root->fn.args_count)
          for (size_t i = 0; i < root->fn.args_count; i++)
            fzl_freeast(root->fn.args[i]);
        free(root->fn.args);
        fzl_freeast(root->fn.body);
        break;
      case FZL_NODETYPE_RETURN:
        if (root->ret.value)
          fzl_freeast(root->ret.value);
        break;
      case FZL_NODETYPE_CLASS:
        if (root->class.fields_count)
          for (size_t i = 0; i < root->class.fields_count; i++)
            fzl_freeast(root->class.fields[i]);
        free(root->class.fields);
        if (root->class.methods_count)
          for (size_t i = 0; i < root->class.methods_count; i++)
            fzl_freeast(root->class.methods[i]);
        free(root->class.methods);
        break;
      case FZL_NODETYPE_CONSTRUCT:
        fzl_freeast(root->construct.name);
        break;
      case FZL_NODETYPE_FIELD:
        fzl_freeast(root->memb.field);
        fzl_freeast(root->memb.parent);
        break;
      case FZL_NODETYPE_DECLARATION:
        if (root->var.identifier)
          fzl_freeast(root->var.identifier);
        break;
    }
-    root = root->next;
+    fzl_node_t *next = root->next;
-    free(root);
+    fzl_freenode(root);
    root = next;
  }
 }
@@ -204,31 +204,31 @@ fzl_token_t *parse_number(fzl_reader_t *reader)
 // Add single-char token
 fzl_token_t *add_single(fzl_reader_t *reader, fzl_toktype_t type)
 {
  size_t p = move(reader, 1);
  fzl_file_loc l;
-  bool ok = fzl_linked_getpos(reader->linked, p, &l);
+  bool ok = fzl_linked_getpos(reader->linked, reader->position, &l);
  if (!ok)
  {
    snprintf(last_err, sizeof(last_err), "failed to locate line:col");
    return NULL;
  }
-  return fzl_mktoken(type, l.line, l.col, NULL, 0, l.filename);
+  move(reader, 1);
  return fzl_mktoken(type, l.line, l.col, "", 0, l.filename);
 }
 // Add double-char token
 fzl_token_t *add_double(fzl_reader_t *reader, fzl_toktype_t type)
 {
  size_t p = move(reader, 2);
  fzl_file_loc l;
-  bool ok = fzl_linked_getpos(reader->linked, p, &l);
+  bool ok = fzl_linked_getpos(reader->linked, reader->position, &l);
  if (!ok)
  {
    snprintf(last_err, sizeof(last_err), "failed to locate line:col");
    return NULL;
  }
-  return fzl_mktoken(type, l.line, l.col, NULL, 0, l.filename);
+  move(reader, 2);
  return fzl_mktoken(type, l.line, l.col, "", 0, l.filename);
 }
 // Skip symbols until '\n' or EOF
@@ -313,7 +313,7 @@ int fzl_read(fzl_reader_t *reader)
      token = add_single(reader, FZL_TOKTYPE_PERCENT);
    else if (curr == '=')
      token = add_single(reader, FZL_TOKTYPE_EQ);
-    else if (curr >= 'A' && curr <= 'Z' || curr >= 'a' && curr <= 'z' ||
+    else if ((curr >= 'A' && curr <= 'Z') || (curr >= 'a' && curr <= 'z') ||
             curr == '_')
      token = parse_name(reader);
    else if (curr >= '0' && curr <= '9')
@@ -353,6 +353,7 @@ int fzl_read(fzl_reader_t *reader)
    }
    fzl_reader_ll_t *tok_node = malloc(sizeof(fzl_reader_ll_t));
    tok_node->next            = NULL;
    tok_node->token           = token;
    reader->last->next = tok_node;
@@ -6,15 +6,20 @@
 fzl_token_t *fzl_mktoken(const fzl_toktype_t type, size_t line, size_t col,
                         void *value, size_t value_len, char *filename)
 {
-  char *valholder = malloc(value_len + 1);
+  char *valholder = NULL;
-  memcpy(valholder, value, value_len);
+
-  valholder[value_len] = '\0';
+  if (value && value_len > 0)
  {
    valholder = malloc(value_len + 1);
    memcpy(valholder, value, value_len);
    valholder[value_len] = '\0';
  }
  fzl_token_t *token = malloc(sizeof(fzl_token_t));
  token->type        = type;
  token->ln          = line;
  token->cn          = col;
-  token->store_value = value_len > 0;
+  token->store_value = (valholder != NULL);
  token->value       = valholder;
  token->value_sz    = value_len;
  token->filename    = filename;
@@ -64,7 +64,7 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
 // --- Walking zone ---
 // Convert type token to `fzl_type_t`
-const fzl_type_t tok_to_type(fzl_token_t *tok)
+fzl_type_t tok_to_type(fzl_token_t *tok)
 {
  if (tok->type == FZL_TOKTYPE_NAME)
    return FZL_TYPE_OBJECT;
@@ -246,6 +246,9 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
          strcpy((method_name + classname_len + 1), fn->fn.name->value);
          method_name[classname_len + fnname_len + 1] = 0;
          if (fn->fn.name->value)
            free(fn->fn.name->value);
          fn->fn.name->value   = method_name;
          fzl_walk_res_t fnres = walk(walker, fn);
          if (fnres.error)
@@ -403,7 +406,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        }
        // NOTE: add sym_top limit check
-        size_t lvl                      = walker->sym_top;
+        ssize_t lvl                     = walker->sym_top;
        walker->syms[walker->sym_top++] = fzl_mksymt();
        fzl_walk_ctx_t *newctx = nest_ctx(walker, FZL_WALK_CTX_TYPE_FN);
@@ -939,7 +942,6 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
        }
        else if (node->token->type == FZL_TOKTYPE_NULL_LITERAL)
        {
          fzl_token_t *tok = node->token;
          push_op(walker, FZL_OPCODE_PUSHNUM);
          push_word(walker, 0);
          push_op(walker, FZL_OPCODE_DEREFERENCE);
@@ -1145,7 +1147,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
          if (obj_res.error)
            return obj_res;
-          fzl_ctable_t *ct;
+          fzl_ctable_t *ct = NULL;
          for (size_t i = 0; i < walker->classes_count; i++)
          {
            if (strcmp(obj_res.classname, walker->classes[i]->name) == 0)
@@ -1164,7 +1166,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
          }
-          fzl_ctable_field_t *ctf;
+          fzl_ctable_field_t *ctf = NULL;
          for (size_t i = 0; i < ct->fields_count; i++)
          {
            if (strcmp(field_node->memb.field->token->value,
@@ -15,9 +15,15 @@ int main(int argc, char **argv)
 {
  fzl_options_t *opts = fzl_mkoptions(argc, argv);
  if (!opts)
  {
    fzl_freeoptions(opts);
    return -1;
  }
  else if (!opts->should_continue)
  {
    fzl_freeoptions(opts);
    return 0;
  }
  if (opts->verbose)
    printf("%s> analyze\n-> reading file...%s", FZL_CDEBUG, FZL_CRST);
@@ -28,6 +34,8 @@ int main(int argc, char **argv)
    char *lasterr = fzl_linked_geterror();
    if (lasterr[0])
      printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, lasterr);
    fzl_freeoptions(opts);
    fzl_freelinked(linked);
    return -1;
  }
@@ -38,6 +46,8 @@ int main(int argc, char **argv)
    char *lasterr = fzl_linked_geterror();
    if (lasterr[0])
      printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, lasterr);
    fzl_freeoptions(opts);
    fzl_freelinked(linked);
    return -1;
  }
@@ -53,6 +63,9 @@ int main(int argc, char **argv)
  if (result != 0)
  {
    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_reader_geterror());
    fzl_freeoptions(opts);
    fzl_freelinked(linked);
    fzl_freereader(rd);
    return -1;
  }
@@ -87,6 +100,10 @@ int main(int argc, char **argv)
  if (result != 0)
  {
    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_parser_geterror());
    fzl_freeoptions(opts);
    fzl_freeparser(parser);
    fzl_freereader(rd);
    fzl_freelinked(linked);
    return -1;
  }
@@ -103,6 +120,11 @@ int main(int argc, char **argv)
  if (result != 0)
  {
    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_walker_geterror());
    fzl_freeoptions(opts);
    fzl_freewalker(walker);
    fzl_freeparser(parser);
    fzl_freereader(rd);
    fzl_freelinked(linked);
    return -1;
  }
@@ -144,6 +166,12 @@ int main(int argc, char **argv)
  if (result != 0)
  {
    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_writer_geterror());
    fzl_freeoptions(opts);
    fzl_freewriter(writer);
    fzl_freewalker(walker);
    fzl_freeparser(parser);
    fzl_freereader(rd);
    fzl_freelinked(linked);
    return -1;
  }
@@ -11,31 +11,31 @@ bool fzl_consts_equal(fzl_const_t a, fzl_const_t b)
  switch (a.type)
  {
-  case FZL_CONSTTYPE_STRING:
+    case FZL_CONSTTYPE_STRING:
-  {
+    {
-    if (a.as.string.length != b.as.string.length)
+      if (a.as.string.length != b.as.string.length)
-      return false;
+        return false;
-    return memcmp(a.as.string.chars, b.as.string.chars, a.as.string.length) ==
+      return memcmp(a.as.string.chars, b.as.string.chars, a.as.string.length) ==
-           0;
+             0;
-  }
+    }
  }
  return false;
 }
-static uint32_t fzl_hash_const(fzl_const_t c)
+uint32_t fzl_hash_const(fzl_const_t c)
 {
-  uint32_t hash = 2166136261u;
+  uint32_t hash       = 2166136261u;
  const uint8_t *data = NULL;
-  size_t size = 0;
+  size_t size         = 0;
  switch (c.type)
  {
-  case FZL_CONSTTYPE_STRING:
+    case FZL_CONSTTYPE_STRING:
-    data = (const uint8_t *)c.as.string.chars;
+      data = (const uint8_t *)c.as.string.chars;
-    size = c.as.string.length;
+      size = c.as.string.length;
-    break;
+      break;
  }
  for (size_t i = 0; i < size; i++)
@@ -51,27 +51,27 @@ fzl_const_hash_pool_t *fzl_mkconstpool()
 {
  fzl_const_hash_pool_t *pool = malloc(sizeof(fzl_const_hash_pool_t));
-  pool->size = 0;
+  pool->size     = 0;
  pool->capacity = 8;
-  pool->array = malloc(pool->capacity * sizeof(fzl_const_t));
+  pool->array    = malloc(pool->capacity * sizeof(fzl_const_t));
-  pool->slots_count = 0;
+  pool->slots_count    = 0;
  pool->slots_capacity = 16;
  pool->slots = malloc(pool->slots_capacity * sizeof(fzl_const_hash_slot_t));
-  for (int i = 0; i < pool->slots_capacity; i++)
+  for (size_t i = 0; i < pool->slots_capacity; i++)
    pool->slots[i].pool_index = -1;
  return pool;
 }
-static void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool)
+void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool)
 {
-  int old_capacity = pool->slots_capacity;
+  int old_capacity                 = pool->slots_capacity;
  fzl_const_hash_slot_t *old_slots = pool->slots;
  pool->slots_capacity = old_capacity * 2;
  pool->slots = malloc(pool->slots_capacity * sizeof(fzl_const_hash_slot_t));
-  for (int i = 0; i < pool->slots_capacity; i++)
+  for (size_t i = 0; i < pool->slots_capacity; i++)
    pool->slots[i].pool_index = -1;
  pool->slots_count = 0;
@@ -81,8 +81,8 @@ static void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool)
      continue;
    int index_in_pool = old_slots[i].pool_index;
-    fzl_const_t c = pool->array[index_in_pool];
+    fzl_const_t c     = pool->array[index_in_pool];
-    uint32_t hash = fzl_hash_const(c);
+    uint32_t hash     = fzl_hash_const(c);
    uint32_t bucket = hash & (pool->slots_capacity - 1);
    while (pool->slots[bucket].pool_index != -1)
@@ -100,7 +100,7 @@ size_t fzl_consts_pool_add(fzl_const_hash_pool_t *pool, fzl_const_t c)
  if (pool->slots_count * 4 >= pool->slots_capacity * 3)
    fzl_consts_pool_resize_hash(pool);
-  uint32_t hash = fzl_hash_const(c);
+  uint32_t hash   = fzl_hash_const(c);
  uint32_t bucket = hash & (pool->slots_capacity - 1);
  while (pool->slots[bucket].pool_index != -1)
@@ -119,7 +119,7 @@ size_t fzl_consts_pool_add(fzl_const_hash_pool_t *pool, fzl_const_t c)
                                         pool->capacity * sizeof(fzl_const_t));
  }
-  size_t new_index = pool->size;
+  size_t new_index       = pool->size;
  pool->array[new_index] = c;
  pool->size++;
@@ -72,9 +72,9 @@ bool fzl_linked_add_files(fzl_linked_t *l, char **files, size_t files_count)
                             .end   = current_start + file_sz - 1};
    if (!l->source)
-      l->source = malloc(file_sz);
+      l->source = malloc(file_sz + 1);
    else
-      l->source = realloc(l->source, current_start + file_sz);
+      l->source = realloc(l->source, current_start + file_sz + 1);
    if (!l->source)
    {
@@ -86,6 +86,7 @@ bool fzl_linked_add_files(fzl_linked_t *l, char **files, size_t files_count)
    }
    strcpy(l->source + current_start, source);
    free(source);
    current_start += file_sz;
  }
@@ -27,7 +27,6 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
  }
  memset(opts, 0, sizeof(fzl_options_t));
  opts->should_continue = true;
  if (argc < 2)
  {
@@ -36,7 +35,7 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
    return opts;
  }
-  size_t i;
+  int i;
  for (i = 1; i < argc; i++)
  {
    if (argv[i][0] != '-')
@@ -82,27 +81,24 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
  size_t fcount     = 0;
  char **files      = malloc(fremainder * sizeof(char *));
-  if (opts->should_continue)
+  for (; i < argc; i++)
  {
-    for (; i < argc; i++)
+    if (argv[i][0] == '-')
    {
-      if (argv[i][0] == '-')
+      printf(
-      {
+          "%sWarning%s: unhandled flag '%s' (should be defined before sources "
-        printf("%sWarning%s: unhandled flag '%s' (should be defined before "
+          "list)\n",
-               "sources "
+          FZL_CWARNING, FZL_CRST, argv[i]);
-               "list)\n",
+      continue;
               FZL_CWARNING, FZL_CRST, argv[i]);
        continue;
      }
      if (fremainder <= fcount)
      {
        fremainder *= 2;
        files = realloc(files, fremainder * sizeof(char *));
      }
      files[fcount++] = argv[i];
    }
    if (fremainder <= fcount)
    {
      fremainder *= 2;
      files = realloc(files, fremainder * sizeof(char *));
    }
    files[fcount++] = argv[i];
  }
  opts->files       = files;
@@ -112,13 +108,14 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
  {
    printf("%sError%s: flags should go before source files list.\n", FZL_CERROR,
           FZL_CRST);
-    printf("Remain %zu arguments are not handled.\n", argc - 1 - i);
+    printf("Remain %d arguments are not handled.\n", argc - 1 - i);
    free(files);
    free(opts);
    return NULL;
  }
  opts->should_continue = true;
  return opts;
 }
@@ -42,6 +42,7 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
  if (!fd)
  {
    snprintf(last_err, sizeof(last_err), "failed to open file '%s'", filepath);
    free(vm);
    return NULL;
  }
@@ -50,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;
  }
@@ -60,6 +63,8 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
  if (ops_count < 1)
  {
    snprintf(last_err, sizeof(last_err), "there is nothing to do (0 ops)");
    fclose(fd);
    free(vm);
    return NULL;
  }
@@ -89,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;
@@ -104,6 +112,7 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
    fread(&op, sizeof(uint64_t), 1, fd);
    vm->ops[i] = op;
  }
  fclose(fd);
  return vm;
 }
@@ -184,7 +193,7 @@ void print_object(fzl_vm_object_t *obj)
    else if (arg.type == FZL_TYPE_UINT)
      printf("uint(%lu)", arg.as.u);
    else if (arg.type == FZL_TYPE_BOOL)
-      printf("bool(%b)", arg.as.b);
+      printf("bool(%s)", arg.as.b ? "true" : "false");
    else if (arg.type == FZL_TYPE_NULL)
      printf("<null>");
    else if (arg.type == FZL_TYPE_OBJECT)
@@ -650,8 +659,17 @@ int fzl_vm_run(fzl_vm_t *vm)
        break;
      case FZL_OPCODE_JMP:
-        vm->ip = vm->ops[++vm->ip] - 1;
+      {
        if (vm->ops_count <= vm->ip)
        {
          snprintf(last_err, sizeof(last_err),
                   "runtime error - expected JMP addr");
          return -1;
        }
        uint64_t jmp_ip = vm->ops[++vm->ip];
        vm->ip          = jmp_ip - 1;
        break;
      }
      case FZL_OPCODE_AND:
        if (vm->dtop < 2)
@@ -723,6 +741,14 @@ int fzl_vm_run(fzl_vm_t *vm)
          }
        }
        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)
@@ -807,7 +833,7 @@ int fzl_vm_run(fzl_vm_t *vm)
          else if (arg.type == FZL_TYPE_UINT)
            printf("%lu\n", arg.as.u);
          else if (arg.type == FZL_TYPE_BOOL)
-            printf("%b\n", arg.as.b);
+            printf("%s\n", arg.as.b ? "true" : "false");
          else if (arg.type == FZL_TYPE_NULL)
            printf("<null>\n");
          else if (arg.type == FZL_TYPE_OBJECT)
@@ -816,7 +842,7 @@ int fzl_vm_run(fzl_vm_t *vm)
        else if (fn_id == FZL_BUILTIN_EXIT)
        {
          fzl_value_t arg = vm->dstack[--vm->dtop];
-          exit(arg.as.i);
+          return arg.as.i;
        }
        else
        {
@@ -985,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)
@@ -7,8 +7,6 @@
 #include <string.h>
 #include <vm/fzl_vm_env.h>
 static const fzl_value_t null = {.type = FZL_TYPE_NULL};
 fzl_vm_env_t *fzl_mkenv()
 {
  fzl_vm_env_t *env = malloc(sizeof(fzl_vm_env_t));
@@ -17,7 +17,6 @@ void print_hint()
  printf("Usage: fz [flags] <file path>\n");
  printf("Flags:\n");
  printf("\t-h\t--help\tprint usage information\n");
  printf("\t-d\t--debug\tdisplay program opcodes\n");
 }
 // Parse passed arguments and build args setup structure
@@ -34,7 +33,7 @@ run_args_t *parse_args(int argc, char **argv)
  args->help       = false;
  args->debug      = false;
-  for (size_t i = 0; i < argc; i++)
+  for (int i = 0; i < argc; i++)
  {
    if (argv[i][0] != '-')
      continue;
@@ -50,6 +49,7 @@ run_args_t *parse_args(int argc, char **argv)
    {
      printf("Error: unknown flag '%s'.\n", argv[i]);
      printf("Use 'fz --help' to read the usage\n");
      free(args);
      return NULL;
    }
  }
@@ -58,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;
  }
@@ -74,6 +75,7 @@ int main(int argc, char **argv)
  else if (args->help)
  {
    print_hint();
    free(args);
    return 0;
  }
@@ -81,6 +83,7 @@ int main(int argc, char **argv)
  if (!vm)
  {
    printf("Error: %s\n", fzl_vm_geterror());
    free(args);
    return -1;
  }
@@ -91,7 +94,12 @@ int main(int argc, char **argv)
    int result = fzl_vm_run(vm);
    if (result != 0)
    {
-      printf("Error: %s\n", fzl_vm_geterror());
+      char *err = fzl_vm_geterror();
      if (err && err[0])
        printf("Error: %s\n", err);
      free(args);
      fzl_freevm(vm);
      return -1;
    }
  }
Author	SHA1	Message	Date
samsonium	1e518c4c82	fix: sanitizer checks fix (iteration 3 - final)	2026-10-19 20:11:48 +03:00
samsonium	3f2f03f931	fix: sanitizer checks fix (iteration 2)	2026-10-19 19:54:11 +03:00
samsonium	1289f6c150	fix: sanitizer checks fix (iteration 1)	2026-10-19 19:41:39 +03:00
samsonium	04b367e7a0	fix: warnings fix (after -Wall -Wextra)	2026-10-19 18:39:40 +03:00
samsonium	d09468cc6b	fix: critical fixes for newer compiler versions - Add token check before parsing statement or program - Fix program freeing	2026-10-19 17:50:31 +03:00