fix: sanitizer checks fix (iteration 3 - final)

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

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)
 

docs/grammar.ebnf

@@ -0,0 +1,6 @@
+program       := statement*
+statement     := expression
+expression    := call | string_literal
+call          := name "(" argument-list? ")"
+argument-list := string_literal ("," string_literal)*
+

docs/ru/book/00_introduction.md

@@ -1,43 +0,0 @@
-# Вступление
-
-Добро пожаловать в небольшую книжку по основам языка FZLang и спасибо, что решились попробовать этот язык программирования.
-
-Для начала, стоит рассказать, что это за язык и как будет идти обучение в этой "книжке".
-
-## Что такое FZLang
-
-FZLang - это язык программирования с собственным тулчейном, включающим в себя компилятор и виртуальную машину.
-Компилятор позволяет проверить и скомпилировать исходный код программы, чтобы сохранить в переносимый файл, а виртуальная машина - выполнить программу, написанную на FZLang.
-
-Изначально, этот проект задумывался как самоучитель по компиляторостроению.
-Мне (Samsonium) было интересно разобрать:
-
-- Почему между компилятором и интерпретатором есть значимая разница?
-- Как программа, под названием "компилятор" понимает, что я хочу сделать?
-- Как устроено исполнение скомпилированной программы? Да и как, вообще, происходит процесс "перевода" с человеческого на машинный?
-
-Я занимаюсь программированием уже более 10 лет, но за всё время так и не удосужился об этом разузнать!
-
-Поэтому, этот проект был рождён как поле для экспериментов, разрабатывая который я стану лучше понимать устройство того, на чём строится весь мир программистов.
-Однако, по ходу разработки у языка стала появлятся своя форма, а также философия.
-
-Сейчас, я бы описал философию языка так: "быть удобным, как инструмент, но всегда стараться оставаться предсказуемым".
-Полагаю, любое комьюнити желает своему языку того же, но мне это помогло сделать определённый выбор в ключевых точках развития.
-
-### Как в FZLang устроена работа с памятью
-
-Изначально вопрос появился после внедрения стеков виртуальной машины, и звучал он так: "сборщик мусора или что-то другое?".
-Изучить работу сборщика было, конечно, интересно.
-Однако мне, человеку, выбравшему Java как первый язык, была знакома его "тяжесть" и "скорость" работы.
-Конечно же, отдельное "спасибо" за это можно сказать его сборщику мусора.
-
-Поэтому, вместо GC я решил посмотреть в сторону RAII и, в итоге, получил хорошую формулу гуляния объекта в программе:
-если объект подан как аргумент, то происходит "заимствование" его во вложенное окружение, и если объект возвращается, то происходит перемещение объекта в родительское окружение.
-Такой подход позволяет не делать GC, а ещё, что самое важное, получить детерминированное время жизни объекта, а значит, детерминированную память (настолько, насколько это возможно).
-
-Короче говоря, FZLang обзавёлся scope-based RAII.
-
----
-
-Далее: [Начало работы](./01_getting-started.md)
-

docs/ru/book/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)

docs/ru/internals/object_layout.md

@@ -1,2 +0,0 @@
-# Размещение объектов
-

docs/ru/internals/opcodes.md

@@ -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 | Взять значение со стека и положить инвертированный булев результат |
-

docs/ru/internals/stacks.md

@@ -1,102 +0,0 @@
-# Стеки виртуальной машины
-
-Во время работы, виртуальная машина FZLang полагается на три стека: данных, окружений и вызовов.
-Каждый стек инициализируется как массив из 256 значений, а затем зануляется.
-Основное свойство, присущее всем трём стекам - последнее значение является верхом стека и сниматься в первую очередь должно оно, декрементируя указатель на вершину стека.
-
-## Стек данных
-
-Стек данных представляет из себя массив из 256 элементов типа `fzl_value_t`.
-Структура `fzl_value_t` - это контейнер для хранения значений, используемых во время работы программы.
-
-```c
-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;
-```
-
-Стек используется во время работы программы виртуальной машиной, чтобы писать и читать промежуточные вычисления.
-К концу работы программы, стек должен быть пуст.
-
-## Стек окружений
-
-Чтобы определять лексическое окружение, в котором на данный момент производятся вычисления и выполняются команды, используется стек окружений.
-Стек окружений - это массив из 256 элементов типа `fzl_vm_env_t`.
-
-```c
-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;
-```
-
-Каждый элемент стека хранит таблицу локальных имён `fzl_vm_env_entry_t`, а также объекты, которые принадлежат текущему окружению.
-Локальное имя - это контейнер, оборачивающий `fzl_value_t` и дающий ему имя:
-
-```c
-typedef struct
-{
-  char *name;
-  fzl_value_t value;
-} fzl_vm_env_entry_t;
-```
-
-Объект же представляет из себя массив полей, хранимых в этом объекте.
-Количество элементов определется при аллокации объекта (опкод `FZL_OPCODE_ALLOC_OBJECT N`, подробнее - в [описании опкодов](./opcodes.md)).
-
-```c
-typedef struct
-{
-  fzl_value_t *values;
-  size_t values_count;
-} fzl_vm_object_t;
-```
-
-Создание окружения или выход из него происходит при опкодах `FZL_OPCODE_MK_ENVTABLE` и `FZL_OPCODE_RM_ENVTABLE` соответственно.
-При этом, если компилятор видит возвращаемое из функции значение типа `FZL_TYPE_OBJECT`, то перед опкодами `FZL_OPCODE_RET` и `FZL_OPCODE_RM_ENVTABLE` он вставляет `FZL_OPCODE_ESCAPE_OBJECT`,
-которое позволяет переместить владение объектом в родительское окружение.
-
-## Стек возврата
-
-Стек возврата хранит адреса инструкций при входе в функцию (через опкод `FZL_OPCODE_CALL`).
-Опкод `FZL_OPCODE_RET` снимает адрес со стека вызовов и прыгает на снятый адрес.
-
-Сам по себе стек представляет из себя 256 элементов типа `size_t`.
-

docs/ru/philosopy.md

@@ -1,31 +0,0 @@
-# Философия языка
-
-Язык FZLang преследует две цели при разработке: "быть удобным, как инструмент, но всегда оставаться предсказуемым".
-
-Вот, какими путями язык пытается достичь этой философии:
-
-## В отношении к памяти и ресурсам
-
-В средах с GC программист точно не знает, в какой момент сборщик мусора решит произвести очистку:
-объект может висеть секундами после завершения метода.
-А в момент очистки рантайм может устроить микропаузу, что критично для аудио, игр, сети или встроенных систем.
-
-В модели scope-based RAII, которая используется в том числе в FZLang, память детерминирована.
-Любой объект имеет область, которая им владеет, а как только область уничтожается - объект уничтожается вместе с ней.
-Время отклика таком подходе равное и предсказуемое.
-
-Ещё один плюс, который предоставляет модель scope-based RAII - это работа с ресурсами (сокеты, файлы).
-Проблема освобождения ресурсов решается чистой семантикой области видимости: умирает скоуп - очищается всё, что к нему привязано.
-
-И последним аргументом в сторону scope-based RAII стало отстутствие оверхеда на рантайм.
-Полноценному GC для работы нужны карты памяти, фоновые потоки, барьеры чтения и записи.
-В FZLang виртуальная машина весит очень мало, а вся память освобождается по ходу чтения инструкций.
-
-## В отношении синтаксиса
-
-Язык FZLang намеренно не упрощается некоторые детали синтаксиса.
-Например, при обращении к экземпляру класса в его методах, использование `this` является обязательным, как и указание типов при декларациях, - это строгая часть.
-Однако, объявление функции без возвращаемого типа позволяет опускать тип, так как писать на месте типа постоянно `void` было бы избыточно.
-
-Таким образом, FZLang старается балансировать между синтаксисом, позволяющим оставаться языку детерминированным и упрощениями, которые действительно уместны.
-

docs/ru/reference/errors_print.md

@@ -1,120 +0,0 @@
-# Вывод ошибок
-
-Если во время работы программы происходит ошибка рантайма, то ВМ выводит своё состояние на момент остановки.
-Среди выводимой информации есть:
-
-1. Указатель на адрес инструкции;
-2. Стек данных;
-3. Стек окружений;
-4. Стек вызовов.
-
-## Указатель на адрес инструкции (IP)
-
-Он может быть полезен для отладки, в паре с выводом опкодов программы.
-Если подать в ВМ флаг `--debug` (`-d`) вместе с путём к скомпилированной программой, то ВМ выведет список опкодов программы без её запуска.
-
-Выглядит вывод программы примерно так:
-
-```
-0000: MK_ENVTABLE
-0001: JMP IP: 53
-0003: MK_ENVTABLE
-0004: LOADCONST #0 ('a')
-0006: STORE
-0007: LOADCONST #0 ('a')
-0009: WRITE
-0010: MK_ENVTABLE
-0011: LOADCONST #0 ('a')
-0013: LOOKUP_ENV
-0014: GET_FIELD #0
-...
-```
-
-Порядковый номер позволяет быстро найти инструкцию, на которой произошло исключение.
-Полный список опкодов и их описание можно найти в документе [списка опкодов](../internals/opcodes.md).
-
-## Стек данных
-
-Стек данных выводится как список значений в стиле `[T] V`, где `T` - номер типа, `V` - значение.
-Если значение является строкой или объектом, то в начале дописывается `str: V` и `ref: V` соответственно.
-
-Вот, как выглядит пример вывода стека:
-
-```
-> Data stack:
-        > [2] str: 'this'
-```
-
-Важно учесть, что значения выводятся сверху вниз. То есть, первыми будут выведены самые свежие значения.
-
-## Стек окружения
-
-Стек окружения выводится как два списка: объекты во владении и локальные для окружения имена.
-
-Пример окружения:
-
-```
-> Environments:
-        > [1] 0x55a9d8196a20:
-                > Owned objects (0/2):
-                > Local entries (3/4):
-                        > [14] b = 4
-                        > [1] a = ref 0x55a9d81969e0
-                        > [0] this = 0
-        > [0] 0x55a9d8196930:
-                > Owned objects (1/2):
-                        > ref: 0x55a9d81969e0 (entries: 1)
-                > Local entries (1/2):
-                        > [1] sum = ref 0x55a9d81969e0
-```
-
-`> [N] A` - это сама таблица окружения.
-`N` - это уровень таблицы, который тем выше, чем глубже само окружение.
-`A` - это адрес таблицы в памяти.
-
-Внутри идёт первый список - "Owned objects", с указанием количества элементов и аллоцированным размером массива `(<кол-во>/<размер>)`.
-Перечисление объектов идёт форматом `ref: A (entries: N)`, где `A` - адрес объекта в памяти, `N` - количество хранимых полей.
-
-Далее идёт список локальных имён - "Local entries", с таким же указанием количества элементов к аллоцированному размеру.
-Формат элемента - `[T] N = V`, где `T` - номер типа, `N` - имя элемента, а `V` - его значение.
-
-## Стек вызовов
-
-На стеке вызовов лежат точки возврата, которые попадают на стек при инструкции `CALL` и съедаются инструкцией `RET`.
-
-```
-> Call stack:
-        > [0] 53
-```
-
-Формат записи простой: `[L] IP`, где `L` - уровень вложенности (больше = глубже), а `IP` - указатель на номер инструкции, на которую нужно прыгнуть после возврата.
-
-## Полный вывод
-
-Итого, полный вывод ошибки выглядит следующим образом:
-
-```
-===== ERROR =====
-> Caused on IP: 21
-
-> Data stack:
-        > [2] str: 'this'
-
-> Environments:
-        > [1] 0x55a9d8196a20:
-                > Owned objects (0/2):
-                > Local entries (3/4):
-                        > [14] b = 4
-                        > [1] a = ref 0x55a9d81969e0
-                        > [0] this = 0
-        > [0] 0x55a9d8196930:
-                > Owned objects (1/2):
-                        > ref: 0x55a9d81969e0 (entries: 1)
-                > Local entries (1/2):
-                        > [1] sum = ref 0x55a9d81969e0
-
-> Call stack:
-        > [0] 53
-Error: runtime error - expected 2 values in data stack
-```
-

docs/ru/reference/grammar.ebnf

@@ -1,61 +0,0 @@
-/* FZL (FromZero Language) syntax */
-/* Version 1 */
-/* Authors: */
-/* - Samsonium (https://git.samsonium.dev/Samsonium) */
-
-<program> ::= <_> <statement>+
-
-<statement> ::= <class_stmt>
-              | <fn_stmt>
-              | <if_stmt>
-              | <block_stmt>
-              | <ret_stmt>
-              | <expr_stmt>
-
-<_>  ::= " "*
-<ws> ::= " "+
-
-<expr_stmt>  ::= <expr> <_> ";" <_>
-<block_stmt> ::= "{" <_> <statement>* "}" <_>
-<ret_stmt>   ::= "return" (<ws> <expr>)? <_> ";" <_>
-
-<class_stmt> ::= "class" <ws> <name> <_> "{" <_> (<declaration> | <fn_stmt>)* "}" <_>
-<fn_stmt>    ::= "fn" <ws> <name> <_> "(" <_> (<param> (<_> "," <_> <param>)*)? ")" <_> <block_stmt>
-<param>      ::= <type> <ws> <name>
-
-<if_stmt> ::= "if" <_> "(" <_> <expr> <_> ")" <_> <statement> (<_> "else" <ws> <statement>)?
-
-/* Assign (lowest epxression priority, right-associative) */
-<expr>        ::= <assign_expr>
-<assign_expr> ::= <new_expr> (<_> "=" <_> <assign_expr>)?
-<new_expr>    ::= ("new" <ws> <name>) | <or_expr>
-<or_expr>     ::= <and_expr> (<_> "||" <_> <and_expr>)*
-<and_expr>    ::= <cond_expr> (<_> "&&" <_> <cond_expr>)*
-<cond_expr>   ::= <term_expr> (<_> <cond_op> <_> <term_expr>)*
-<cond_op>     ::= "==" | "!=" | "<=" | ">=" | "<" | ">"
-
-<term_expr>   ::= <factor_expr> (<_> ("+" | "-") <_> <factor_expr>)*
-<factor_expr> ::= <power_expr> (<_> ("*" | "/" | "%") <_> <power_expr>)*
-<power_expr>  ::= <unary_expr> (<_> "^" <_> <power_expr>)?
-<unary_expr>  ::= (("!" | "-" | "+") <_>)* <postfix_expr>
-
-/* Postfix: chain of calls and dots */
-<postfix_expr>  ::= <primary_expr> (<call_suffix> | <member_suffix>)*
-<call_suffix>   ::= <_> "(" <_> (<expr> (<_> "," <_> <expr>)*)? <_> ")"
-<member_suffix> ::= <_> "." <_> <name>
-
-<primary_expr> ::= <literal>
-                 | <declaration>
-                 | "(" <_> <expr> <_> ")"
-                 | <name>
-
-<declaration> ::= <type> <ws> <name>
-
-<type> ::= "int" | "uint" | "bool" | "char" | "str"
-         | "i8" | "i16" | "i32" | "i64"
-         | "u8" | "u16" | "u32" | "u64"
-
-<literal>        ::= <number> | <string_literal> | "true" | "false" | "null"
-<name>           ::= ([A-z] | "_") | ([A-z] | [0-9] | "_")*
-<string_literal> ::= ('"' [^"]* '"') | ("'" [^']* "'") 
-

docs/ru/reference/grammar_ebnf.md

@@ -1,2 +0,0 @@
-# Грамматика (EBNF)
-

docs/ru/reference/operators.md

@@ -1,40 +0,0 @@
-# Операторы
-
-FZLang поддерживает арифметические, логические и унарные операции.
-Во время работы бинарные операции достают со стека два значения, и обратно кладут результат на стек.
-Унарные операции достают одно значение со стека, а затем кладут результат обратно на стек.
-
-## Арифметические операции
-
-| Операция | Допустимые типы | Описание |
-| -------- | --------------- | -------- |
-| `N + N` | *все числовые* | Сложение двух операндов |
-| `N - N` | *все числовые* | Вычитание правого операнда из левого |
-| `N * N` | *все числовые* | Переменожение двух операндов |
-| `N / N` | *все числовые* | Деление левого операнда на правый |
-| `N % N` | *все числовые* | Получение остатка от деления левого операнда на правый |
-| `N ^ N` | *все числовые* | Возведение левого операнда в степень правого |
-| `-N` | *все числовые* | Инверсия операнда |
-
-## Операции сравнения
-
-| Операция | Допустимые типы | Описание |
-| -------- | --------------- | -------- |
-| `N == N` | *все числовые*, булевы, объекты, строки | Сравнить равенство операндов |
-| `N != N` | *все числовые*, булевы, объекты, строки | Сравнить неравенство операндов |
-| `N > N` | *все числовые* | Проверить, что левый операнд больше правого |
-| `N >= N` | *все числовые* | Проверить, что левый операнд больше или равен правому |
-| `N < N` | *все числовые* | Проверить, что левый операнд меньше правого |
-| `N <= N` | *все числовые* | Проверить, что левый операнд меньше или равен правому |
-| `!N` | булевы | Инвертировать операнд |
-
-> Важно:
-> В случае сравнения объектов (`==`, `!=`), сравниваются адреса, а не значения!
-
-## Логические операции
-
-| Операция | Допустимые типы | Описание |
-| -------- | --------------- | -------- |
-| `N && N` | булевы | Логическое **И** двух операндов |
-| `N || N` | булевы | Логическое **ИЛИ** двух операндов |
-

docs/ru/reference/types_system.md

@@ -1,54 +0,0 @@
-# Система типов
-
-FZLang имеет две основы для типов: примитивы и объекты.
-
-Примитивами являются строки, числовые типы, булевы и скрытый тип - "объект".
-Объектами на данный момент являются экземпляры классов, а также литерал `null`.
-
-## Таблица типов
-
-| Внутреннее имя  | Синтаксическое имя | Описание |
-| --------------- | ------------------ | -------- |
-| FZL_TYPE_NULL   | *отстутсвует* | *на данный момент не используется* |
-| FZL_TYPE_OBJECT | *отстутсвует* | экземпляр класса или литерал `null` |
-| FZL_TYPE_STRING | `str` | строка |
-| FZL_TYPE_CHAR   | `char` | *на данный момент не используется* |
-| FZL_TYPE_BOOL   | `bool` | булева |
-| FZL_TYPE_INT8 | `i8` | 8-битное знаковое число |
-| FZL_TYPE_UINT8 | `u8` | 8-битное беззнаковое число |
-| FZL_TYPE_INT16 | `i16` | 16-битное знаковое число |
-| FZL_TYPE_UINT16 | `u16` | 16-битное беззнаковое число |
-| FZL_TYPE_INT32 | `i32` | 32-битное знаковое число |
-| FZL_TYPE_UINT32 | `u32` | 32-битное беззнаковое число |
-| FZL_TYPE_INT64 | `i64` | 64-битное знаковое число |
-| FZL_TYPE_UINT64 | `u64` | 64-битное беззнаковое число |
-| FZL_TYPE_INT | `int` | знаковое число размером с машинное слово |
-| FZL_TYPE_UINT | `uint` | беззнаковое число размером с машинное слово |
-
-
-## Совместимость
-
-При проверке совместимости типов работают следующие правила:
-
-1. Если оба типа - объекты (`FZL_TYPE_OBJECT`), то:
-  1. Если один из типов имеет имя класса `<nullptr>`, проверка **пройдена**;
-  2. Если оба типа имеют одинаковое имя класса, проверка **пройдена**;
-  3. В ином случае проверка **не пройдена**.
-2. Если типы равны, проверка **пройдена**;
-3. Если оба типа - числовые (`u8`..`uint`, `i8`..`int`), проверка **пройдена**;
-4. Если ни одно правило из вышеперечисленных не сработало, то проверка **не пройдена**.
-
-**пройдена** = типы совместимы, **не пройдена** - не совместимы.
-
-## Работа в рантайме
-
-Для примитивов (т.е., не `FZL_TYPE_OBJECT`), значения используются прямо.
-Это значит, что они все операции, работающие со значениями используют для работы то значение, что лежит в контейнере на стеке.
-
-Объектные типы хранятся на стеке как **ссылки на объект**.
-Для них валидные такие операции, как:
-
-- `FZL_OPCODE_ESCAPE_OBJECT` (эвакуация объекта в родительское окружение)
-- `FZL_OPCODE_GET_FIELD N` (чтение поля с индексом `N` из объекта)
-- `FZL_OPCODE_SET_FIELD N` (запись значения в поле объекта с индексом `N`)
-

docs/ru/stdlib/builtins.md

@@ -1,23 +0,0 @@
-# Встроенные функции
-
-В языке FZLang предусмотрены встроеные функции, доступные для использования в любой программе.
-
-## Выход `exit`
-
-```
-fn exit(uint code)
-```
-
-Функция принимает аргументом беззнаковое число и выходит из программы с указанным кодом.
-
-## Вывод в stdout `printline`
-
-```
-fn printline(value)
-```
-
-Принимает аргументом любое значение и выводит в стандартный вывод указанное значение.
-Для примитивы выводятся чисто, на основе типа.
-Объекты выводятся как `obj<...>`, где `...` - перечисление значений полей.
-Поля выводятся по типу и значению в формате: `T<V>`, где `T` - название типа, `V` - текущее значение.
-

include/compiler/utils/fzl_const_pool.h

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

src/compiler/fzl_debug.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)

src/compiler/fzl_parser.c

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

src/compiler/fzl_reader.c

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

src/compiler/fzl_token.c

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

src/compiler/fzl_walker.c

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

src/compiler/main.c

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

src/compiler/utils/fzl_const_pool.c

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

src/compiler/utils/fzl_linked.c

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

src/compiler/utils/fzl_options.c

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

src/vm/fzl_vm.c

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

src/vm/fzl_vm_env.c

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

src/vm/main.c

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