Compare commits
4
Commits
v1.0
..
81d07aa6e5
| Author | SHA1 | Date | |
|---|---|---|---|
 samsonium
|
81d07aa6e5 | ||
|
samsonium
|
306be6b82d | ||
|
samsonium
|
c2532ae11f | ||
|
samsonium
|
345d711570 |
+1
-7
@@ -1,14 +1,8 @@
|
||||
cmake_minimum_required(VERSION 3.16)
|
||||
cmake_minimum_required(VERSION 4.3)
|
||||
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)
|
||||
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
program := statement*
|
||||
statement := expression
|
||||
expression := call | string_literal
|
||||
call := name "(" argument-list? ")"
|
||||
argument-list := string_literal ("," string_literal)*
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
# Вступление
|
||||
|
||||
Добро пожаловать в небольшую книжку по основам языка FZLang и спасибо, что решились попробовать этот язык программирования.
|
||||
|
||||
Для начала, стоит рассказать, что это за язык и как будет идти обучение в этой "книжке".
|
||||
|
||||
## Что такое FZLang
|
||||
|
||||
FZLang - это язык программирования с собственным тулчейном, включающим в себя компилятор и виртуальную машину.
|
||||
Компилятор позволяет проверить и скомпилировать исходный код программы, чтобы сохранить в переносимый файл, а виртуальная машина - выполнить программу, написанную на FZLang.
|
||||
|
||||
Изначально, этот проект задумывался как самоучитель по компиляторостроению.
|
||||
Мне (Samsonium) было интересно разобрать:
|
||||
|
||||
- Почему между компилятором и интерпретатором есть значимая разница?
|
||||
- Как программа, под названием "компилятор" понимает, что я хочу сделать?
|
||||
- Как устроено исполнение скомпилированной программы? Да и как, вообще, происходит процесс "перевода" с человеческого на машинный?
|
||||
|
||||
Я занимаюсь программированием уже более 10 лет, но за всё время так и не удосужился об этом разузнать!
|
||||
|
||||
Поэтому, этот проект был рождён как поле для экспериментов, разрабатывая который я стану лучше понимать устройство того, на чём строится весь мир программистов.
|
||||
Однако, по ходу разработки у языка стала появлятся своя форма, а также философия.
|
||||
|
||||
Сейчас, я бы описал философию языка так: "быть удобным, как инструмент, но всегда стараться оставаться предсказуемым".
|
||||
Полагаю, любое комьюнити желает своему языку того же, но мне это помогло сделать определённый выбор в ключевых точках развития.
|
||||
|
||||
### Как в FZLang устроена работа с памятью
|
||||
|
||||
Изначально вопрос появился после внедрения стеков виртуальной машины, и звучал он так: "сборщик мусора или что-то другое?".
|
||||
Изучить работу сборщика было, конечно, интересно.
|
||||
Однако мне, человеку, выбравшему Java как первый язык, была знакома его "тяжесть" и "скорость" работы.
|
||||
Конечно же, отдельное "спасибо" за это можно сказать его сборщику мусора.
|
||||
|
||||
Поэтому, вместо GC я решил посмотреть в сторону RAII и, в итоге, получил хорошую формулу гуляния объекта в программе:
|
||||
если объект подан как аргумент, то происходит "заимствование" его во вложенное окружение, и если объект возвращается, то происходит перемещение объекта в родительское окружение.
|
||||
Такой подход позволяет не делать GC, а ещё, что самое важное, получить детерминированное время жизни объекта, а значит, детерминированную память (настолько, насколько это возможно).
|
||||
|
||||
Короче говоря, FZLang обзавёлся scope-based RAII.
|
||||
|
||||
---
|
||||
|
||||
Далее: [Начало работы](./01_getting-started.md)
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
# Начало работы
|
||||
|
||||
Для того, чтобы начать работу с 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)
|
||||
@@ -0,0 +1,53 @@
|
||||
# Основы и типы
|
||||
|
||||
В этой главе разберём выражения, переменные и значения 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)
|
||||
@@ -0,0 +1,43 @@
|
||||
# Управление потоком
|
||||
|
||||
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)
|
||||
@@ -0,0 +1,44 @@
|
||||
# Функции и рекурсия
|
||||
|
||||
Функция объявляется ключевым словом `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)
|
||||
@@ -0,0 +1,46 @@
|
||||
# Классы и объекты
|
||||
|
||||
Класс описывается блоком с полями и методами:
|
||||
|
||||
```
|
||||
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)
|
||||
@@ -0,0 +1,36 @@
|
||||
# Модель памяти
|
||||
|
||||
FZLang использует scope-based RAII: объект принадлежит окружению, в котором создан, и освобождается при уничтожении этого окружения.
|
||||
Отдельного сборщика мусора нет.
|
||||
|
||||
## Окружения
|
||||
|
||||
Глобальная программа, функция и каждый блок получают окружение.
|
||||
В нём хранятся имена и значения переменных.
|
||||
При поиске имени VM проверяет текущее окружение, затем внешние.
|
||||
|
||||
После return локальное окружение функции закрывается.
|
||||
Возвращаемый объект переносится в родительское окружение, чтобы пережить этот момент.
|
||||
|
||||
## Владение объектом
|
||||
|
||||
Передача объекта во вложенный вызов позволяет использовать его во внутреннем окружении.
|
||||
Операция `ESCAPE_OBJECT` переносит возвращаемый объект и его дочерние объекты наружу.
|
||||
|
||||
```
|
||||
fn make() Animal
|
||||
{
|
||||
Animal result = new Animal;
|
||||
return result;
|
||||
}
|
||||
```
|
||||
|
||||
Числа, булевы значения и строки хранятся как значения контейнера ВМ.
|
||||
Объектное значение содержит указатель на структуру экземпляра, а поля занимают числовые слоты класса.
|
||||
|
||||
Объект не следует использовать после завершения окружения, которому он принадлежал.
|
||||
Возвращайте его из функции или храните в объекте/окружении с большим временем жизни.
|
||||
|
||||
---
|
||||
|
||||
Назад: [Классы и объекты](./05_classes-and-objects.md)
|
||||
@@ -0,0 +1,21 @@
|
||||
# Размещение объектов
|
||||
|
||||
Экземпляр класса во время исполнения представлен структурой объекта с массивом значений полей:
|
||||
|
||||
```
|
||||
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` переносит владение в родительское окружение.
|
||||
@@ -0,0 +1,119 @@
|
||||
# Опкоды
|
||||
|
||||
Программы, написанные на 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 | Взять значение со стека и положить инвертированный булев результат |
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
# Стеки виртуальной машины
|
||||
|
||||
ВМ использует три фиксированных стека по 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` печатает декодированную последовательность опкодов и аргументов.
|
||||
@@ -0,0 +1,31 @@
|
||||
# Философия языка
|
||||
|
||||
Язык FZLang преследует две цели при разработке: "быть удобным, как инструмент, но всегда оставаться предсказуемым".
|
||||
|
||||
Вот, какими путями язык пытается достичь этой философии:
|
||||
|
||||
## В отношении к памяти и ресурсам
|
||||
|
||||
В средах с GC программист точно не знает, в какой момент сборщик мусора решит произвести очистку:
|
||||
объект может висеть секундами после завершения метода.
|
||||
А в момент очистки рантайм может устроить микропаузу, что критично для аудио, игр, сети или встроенных систем.
|
||||
|
||||
В модели scope-based RAII, которая используется в том числе в FZLang, память детерминирована.
|
||||
Любой объект имеет область, которая им владеет, а как только область уничтожается - объект уничтожается вместе с ней.
|
||||
Время отклика таком подходе равное и предсказуемое.
|
||||
|
||||
Ещё один плюс, который предоставляет модель scope-based RAII - это работа с ресурсами (сокеты, файлы).
|
||||
Проблема освобождения ресурсов решается чистой семантикой области видимости: умирает скоуп - очищается всё, что к нему привязано.
|
||||
|
||||
И последним аргументом в сторону scope-based RAII стало отстутствие оверхеда на рантайм.
|
||||
Полноценному GC для работы нужны карты памяти, фоновые потоки, барьеры чтения и записи.
|
||||
В FZLang виртуальная машина весит очень мало, а вся память освобождается по ходу чтения инструкций.
|
||||
|
||||
## В отношении синтаксиса
|
||||
|
||||
Язык FZLang намеренно не упрощается некоторые детали синтаксиса.
|
||||
Например, при обращении к экземпляру класса в его методах, использование `this` является обязательным, как и указание типов при декларациях, - это строгая часть.
|
||||
Однако, объявление функции без возвращаемого типа позволяет опускать тип, так как писать на месте типа постоянно `void` было бы избыточно.
|
||||
|
||||
Таким образом, FZLang старается балансировать между синтаксисом, позволяющим оставаться языку детерминированным и упрощениями, которые действительно уместны.
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
# Интерфейс компилятора
|
||||
|
||||
Компилятор называется `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` печатает опкоды, не выполняя программу.
|
||||
@@ -0,0 +1,33 @@
|
||||
# Грамматика (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` литералы. Комментарии `// ...` и пробельные символы между токенами игнорируются.
|
||||
@@ -0,0 +1,17 @@
|
||||
# Операторы
|
||||
|
||||
| Оператор | Назначение |
|
||||
| -------------------- | -------------------------------------- |
|
||||
| +, - | Сложение/вычитание, унарные плюс/минус |
|
||||
| *, /, % | Умножение, деление, остаток |
|
||||
| ^ | Возведение в степень |
|
||||
| ==, !=, <, <=, >, >= | Сравнение |
|
||||
| ! | Логическое отрицание |
|
||||
| &&, || | Логические И и ИЛИ |
|
||||
| = | Присваивание |
|
||||
| . | Доступ к полю и методу |
|
||||
|
||||
Для строк и объектов доступны только `==` и `!=`.
|
||||
Ключевое слово `new` создаёт экземпляр класса: `new Point`.
|
||||
|
||||
Приоритет от большего к меньшему: унарные операции; ^; *, /, %; +, -; сравнения; &&; ||; =. Скобки имеют высший приоритет.
|
||||
@@ -0,0 +1,22 @@
|
||||
# Система типов
|
||||
|
||||
| Типы | Значение |
|
||||
| ----------------- | ---------------------------------------- |
|
||||
| int, uint | Целое машинного размера |
|
||||
| i8, i16, i32, i64 | Знаковые целые фиксированного размера |
|
||||
| u8, u16, u32, u64 | Беззнаковые целые фиксированного размера |
|
||||
| str | Строка |
|
||||
| char | Символ |
|
||||
| bool | Булево значение |
|
||||
| ClassName | Экземпляр пользовательского класса |
|
||||
|
||||
Также существует `null`, применимое к объектным значениям.
|
||||
Тип указывается при объявлении переменной, поля и аргумента функции.
|
||||
|
||||
Объект совместим с объектом того же класса или с `null`.
|
||||
Объекты разных классов несовместимы.
|
||||
Строки поддерживают `==` и `!=`, объекты сравниваются по ссылке.
|
||||
Поля класса имеют объявленные типы и последовательные слоты.
|
||||
|
||||
Для функции тип результата указывается после списка параметров.
|
||||
Для функции без результата его можно опустить.
|
||||
@@ -0,0 +1,30 @@
|
||||
# Встроенные функции
|
||||
|
||||
Встроенные функции распознаются компилятором по имени и исполняются ВМ напрямую.
|
||||
|
||||
## 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
|
||||
{
|
||||
ssize_t pool_index;
|
||||
size_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
|
||||
uint32_t fzl_hash_const(fzl_const_t c);
|
||||
static uint32_t fzl_hash_const(fzl_const_t c);
|
||||
|
||||
// Allocate constants hash pool
|
||||
fzl_const_hash_pool_t *fzl_mkconstpool();
|
||||
|
||||
// Resize the hash table
|
||||
void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool);
|
||||
static 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,6 +27,7 @@ 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)
|
||||
|
||||
+63
-130
@@ -9,24 +9,6 @@
|
||||
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)
|
||||
@@ -53,7 +35,6 @@ 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;
|
||||
@@ -75,6 +56,19 @@ 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)
|
||||
{
|
||||
@@ -211,6 +205,7 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
|
||||
return NULL;
|
||||
|
||||
fzl_node_t *left = parse_primary(parser);
|
||||
fzl_node_t *right = NULL;
|
||||
|
||||
if (!left)
|
||||
{
|
||||
@@ -245,7 +240,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;
|
||||
@@ -719,27 +714,19 @@ fzl_node_t *parse_class(fzl_parser_t *parser)
|
||||
}
|
||||
}
|
||||
|
||||
fzl_node_t **new_args = realloc(node->fn.args, (++node->fn.args_count) *
|
||||
sizeof(fzl_node_t *));
|
||||
if (!new_args)
|
||||
{
|
||||
snprintf(plast_err, sizeof(plast_err),
|
||||
"failed to reallocate method args list");
|
||||
free(fields);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (node->fn.args_count > 1)
|
||||
memmove(&new_args[1], new_args,
|
||||
fzl_node_t **new_args = realloc(node->fn.args, ++node->fn.args_count);
|
||||
memcpy(&new_args[1], new_args,
|
||||
(node->fn.args_count - 1) * sizeof(fzl_node_t *));
|
||||
|
||||
fzl_node_t *this_id = fzl_mknode(FZL_NODETYPE_IDENTIFIER, &this_tok);
|
||||
fzl_token_t *this_tok =
|
||||
fzl_mktoken(FZL_TOKTYPE_NAME, node->fn.name->ln, node->fn.name->cn,
|
||||
"this", 4, node->fn.name->filename);
|
||||
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
|
||||
@@ -780,14 +767,6 @@ fzl_node_t *parse_function(fzl_parser_t *parser)
|
||||
return NULL;
|
||||
|
||||
fzl_token_t *fn = consume(parser);
|
||||
if (fn->type != FZL_TOKTYPE_FUNCTION)
|
||||
{
|
||||
snprintf(plast_err, sizeof(plast_err),
|
||||
"'%s': expected keyword 'fn' at %ld:%ld", last_known_tok->filename,
|
||||
last_known_tok->ln, last_known_tok->cn);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
fzl_token_t *name = consume(parser);
|
||||
if (!name || name->type != FZL_TOKTYPE_NAME)
|
||||
{
|
||||
@@ -841,7 +820,8 @@ fzl_node_t *parse_function(fzl_parser_t *parser)
|
||||
type = consume(parser);
|
||||
|
||||
if (!type)
|
||||
type = &null_tok;
|
||||
type = fzl_mktoken(FZL_TOKTYPE_TYPE, last_known_tok->ln, last_known_tok->cn,
|
||||
"null", 4, last_known_tok->filename);
|
||||
|
||||
if (!is(parser, FZL_TOKTYPE_LBRACE))
|
||||
{
|
||||
@@ -979,9 +959,6 @@ 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))
|
||||
@@ -1013,9 +990,6 @@ 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;
|
||||
@@ -1049,8 +1023,6 @@ 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;
|
||||
@@ -1077,13 +1049,8 @@ void fzl_freeast(fzl_node_t *root)
|
||||
|
||||
while (root)
|
||||
{
|
||||
switch (root->type)
|
||||
if (root->type == FZL_NODETYPE_BLOCK)
|
||||
{
|
||||
case FZL_NODETYPE_IDENTIFIER:
|
||||
case FZL_NODETYPE_LITERAL:
|
||||
break;
|
||||
|
||||
case FZL_NODETYPE_BLOCK:
|
||||
if (root->list.entries)
|
||||
{
|
||||
for (size_t i = 0; i < root->list.entry_count; i++)
|
||||
@@ -1092,104 +1059,70 @@ void fzl_freeast(fzl_node_t *root)
|
||||
|
||||
free(root->list.entries);
|
||||
}
|
||||
break;
|
||||
|
||||
case FZL_NODETYPE_CALL:
|
||||
if (root->call.callee)
|
||||
fzl_freeast(root->call.callee);
|
||||
|
||||
}
|
||||
else if (root->type == FZL_NODETYPE_CALL)
|
||||
{
|
||||
if (root->call.args_count)
|
||||
{
|
||||
for (size_t i = 0; i < root->call.args_count; i++)
|
||||
if (root->call.args[i])
|
||||
fzl_freeast(root->call.args[i]);
|
||||
}
|
||||
if (root->call.args)
|
||||
|
||||
free(root->call.args);
|
||||
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:
|
||||
}
|
||||
}
|
||||
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);
|
||||
break;
|
||||
|
||||
case FZL_NODETYPE_UNARY_PLUS:
|
||||
case FZL_NODETYPE_UNARY_MINUS:
|
||||
case FZL_NODETYPE_NOT:
|
||||
}
|
||||
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);
|
||||
break;
|
||||
|
||||
case FZL_NODETYPE_FUNCTION:
|
||||
}
|
||||
else if (root->type == 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]);
|
||||
fzl_freenode(root->fn.args[i]);
|
||||
free(root->fn.args);
|
||||
fzl_freeast(root->fn.body);
|
||||
break;
|
||||
|
||||
case FZL_NODETYPE_RETURN:
|
||||
fzl_freenode(root->fn.body);
|
||||
}
|
||||
else if (root->type == FZL_NODETYPE_RETURN)
|
||||
{
|
||||
if (root->ret.value)
|
||||
fzl_freeast(root->ret.value);
|
||||
break;
|
||||
|
||||
case FZL_NODETYPE_CLASS:
|
||||
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_freeast(root->class.fields[i]);
|
||||
fzl_freenode(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]);
|
||||
fzl_freenode(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;
|
||||
}
|
||||
else if (root->type == FZL_NODETYPE_CONSTRUCT)
|
||||
{
|
||||
fzl_freenode(root->construct.name);
|
||||
}
|
||||
else if (root->type == FZL_NODETYPE_FIELD)
|
||||
{
|
||||
fzl_freenode(root->memb.field);
|
||||
fzl_freenode(root->memb.parent);
|
||||
}
|
||||
|
||||
fzl_node_t *next = root->next;
|
||||
fzl_freenode(root);
|
||||
root = next;
|
||||
root = root->next;
|
||||
free(root);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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, reader->position, &l);
|
||||
bool ok = fzl_linked_getpos(reader->linked, p, &l);
|
||||
if (!ok)
|
||||
{
|
||||
snprintf(last_err, sizeof(last_err), "failed to locate line:col");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
move(reader, 1);
|
||||
return fzl_mktoken(type, l.line, l.col, "", 0, l.filename);
|
||||
return fzl_mktoken(type, l.line, l.col, NULL, 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, reader->position, &l);
|
||||
bool ok = fzl_linked_getpos(reader->linked, p, &l);
|
||||
if (!ok)
|
||||
{
|
||||
snprintf(last_err, sizeof(last_err), "failed to locate line:col");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
move(reader, 2);
|
||||
return fzl_mktoken(type, l.line, l.col, "", 0, l.filename);
|
||||
return fzl_mktoken(type, l.line, l.col, NULL, 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,7 +353,6 @@ 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,20 +6,15 @@
|
||||
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 = NULL;
|
||||
|
||||
if (value && value_len > 0)
|
||||
{
|
||||
valholder = malloc(value_len + 1);
|
||||
char *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 = (valholder != NULL);
|
||||
token->store_value = value_len > 0;
|
||||
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`
|
||||
fzl_type_t tok_to_type(fzl_token_t *tok)
|
||||
const fzl_type_t tok_to_type(fzl_token_t *tok)
|
||||
{
|
||||
if (tok->type == FZL_TOKTYPE_NAME)
|
||||
return FZL_TYPE_OBJECT;
|
||||
@@ -246,9 +246,6 @@ 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)
|
||||
@@ -406,7 +403,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
|
||||
}
|
||||
|
||||
// NOTE: add sym_top limit check
|
||||
ssize_t lvl = walker->sym_top;
|
||||
size_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);
|
||||
@@ -942,6 +939,7 @@ 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);
|
||||
@@ -1147,7 +1145,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 = NULL;
|
||||
fzl_ctable_t *ct;
|
||||
for (size_t i = 0; i < walker->classes_count; i++)
|
||||
{
|
||||
if (strcmp(obj_res.classname, walker->classes[i]->name) == 0)
|
||||
@@ -1166,7 +1164,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 = NULL;
|
||||
fzl_ctable_field_t *ctf;
|
||||
for (size_t i = 0; i < ct->fields_count; i++)
|
||||
{
|
||||
if (strcmp(field_node->memb.field->token->value,
|
||||
|
||||
@@ -15,15 +15,9 @@ 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);
|
||||
@@ -34,8 +28,6 @@ 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;
|
||||
}
|
||||
|
||||
@@ -46,8 +38,6 @@ 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;
|
||||
}
|
||||
|
||||
@@ -63,9 +53,6 @@ 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;
|
||||
}
|
||||
|
||||
@@ -100,10 +87,6 @@ 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;
|
||||
}
|
||||
|
||||
@@ -120,11 +103,6 @@ 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;
|
||||
}
|
||||
|
||||
@@ -166,12 +144,6 @@ 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;
|
||||
}
|
||||
|
||||
|
||||
@@ -24,7 +24,7 @@ bool fzl_consts_equal(fzl_const_t a, fzl_const_t b)
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t fzl_hash_const(fzl_const_t c)
|
||||
static uint32_t fzl_hash_const(fzl_const_t c)
|
||||
{
|
||||
uint32_t hash = 2166136261u;
|
||||
const uint8_t *data = NULL;
|
||||
@@ -58,20 +58,20 @@ fzl_const_hash_pool_t *fzl_mkconstpool()
|
||||
pool->slots_count = 0;
|
||||
pool->slots_capacity = 16;
|
||||
pool->slots = malloc(pool->slots_capacity * sizeof(fzl_const_hash_slot_t));
|
||||
for (size_t i = 0; i < pool->slots_capacity; i++)
|
||||
for (int i = 0; i < pool->slots_capacity; i++)
|
||||
pool->slots[i].pool_index = -1;
|
||||
|
||||
return pool;
|
||||
}
|
||||
|
||||
void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool)
|
||||
static void fzl_consts_pool_resize_hash(fzl_const_hash_pool_t *pool)
|
||||
{
|
||||
int old_capacity = pool->slots_capacity;
|
||||
fzl_const_hash_slot_t *old_slots = pool->slots;
|
||||
|
||||
pool->slots_capacity = old_capacity * 2;
|
||||
pool->slots = malloc(pool->slots_capacity * sizeof(fzl_const_hash_slot_t));
|
||||
for (size_t i = 0; i < pool->slots_capacity; i++)
|
||||
for (int i = 0; i < pool->slots_capacity; i++)
|
||||
pool->slots[i].pool_index = -1;
|
||||
pool->slots_count = 0;
|
||||
|
||||
|
||||
@@ -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 + 1);
|
||||
l->source = malloc(file_sz);
|
||||
else
|
||||
l->source = realloc(l->source, current_start + file_sz + 1);
|
||||
l->source = realloc(l->source, current_start + file_sz);
|
||||
|
||||
if (!l->source)
|
||||
{
|
||||
@@ -86,7 +86,6 @@ 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,6 +27,7 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
|
||||
}
|
||||
|
||||
memset(opts, 0, sizeof(fzl_options_t));
|
||||
opts->should_continue = true;
|
||||
|
||||
if (argc < 2)
|
||||
{
|
||||
@@ -35,7 +36,7 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
|
||||
return opts;
|
||||
}
|
||||
|
||||
int i;
|
||||
size_t i;
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
if (argv[i][0] != '-')
|
||||
@@ -81,12 +82,14 @@ 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++)
|
||||
{
|
||||
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 "
|
||||
"sources "
|
||||
"list)\n",
|
||||
FZL_CWARNING, FZL_CRST, argv[i]);
|
||||
continue;
|
||||
@@ -100,6 +103,7 @@ fzl_options_t *fzl_mkoptions(int argc, char **argv)
|
||||
|
||||
files[fcount++] = argv[i];
|
||||
}
|
||||
}
|
||||
|
||||
opts->files = files;
|
||||
opts->files_count = fcount;
|
||||
@@ -108,14 +112,13 @@ 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 %d arguments are not handled.\n", argc - 1 - i);
|
||||
printf("Remain %zu arguments are not handled.\n", argc - 1 - i);
|
||||
|
||||
free(files);
|
||||
free(opts);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
opts->should_continue = true;
|
||||
return opts;
|
||||
}
|
||||
|
||||
|
||||
+4
-33
@@ -42,7 +42,6 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
|
||||
if (!fd)
|
||||
{
|
||||
snprintf(last_err, sizeof(last_err), "failed to open file '%s'", filepath);
|
||||
free(vm);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -51,8 +50,6 @@ 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;
|
||||
}
|
||||
|
||||
@@ -63,8 +60,6 @@ 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;
|
||||
}
|
||||
|
||||
@@ -94,9 +89,6 @@ 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;
|
||||
@@ -112,7 +104,6 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
|
||||
fread(&op, sizeof(uint64_t), 1, fd);
|
||||
vm->ops[i] = op;
|
||||
}
|
||||
fclose(fd);
|
||||
|
||||
return vm;
|
||||
}
|
||||
@@ -193,7 +184,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(%s)", arg.as.b ? "true" : "false");
|
||||
printf("bool(%b)", arg.as.b);
|
||||
else if (arg.type == FZL_TYPE_NULL)
|
||||
printf("<null>");
|
||||
else if (arg.type == FZL_TYPE_OBJECT)
|
||||
@@ -659,17 +650,8 @@ int fzl_vm_run(fzl_vm_t *vm)
|
||||
break;
|
||||
|
||||
case FZL_OPCODE_JMP:
|
||||
{
|
||||
if (vm->ops_count <= vm->ip)
|
||||
{
|
||||
snprintf(last_err, sizeof(last_err),
|
||||
"runtime error - expected JMP addr");
|
||||
return -1;
|
||||
}
|
||||
uint64_t jmp_ip = vm->ops[++vm->ip];
|
||||
vm->ip = jmp_ip - 1;
|
||||
vm->ip = vm->ops[++vm->ip] - 1;
|
||||
break;
|
||||
}
|
||||
|
||||
case FZL_OPCODE_AND:
|
||||
if (vm->dtop < 2)
|
||||
@@ -741,14 +723,6 @@ 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)
|
||||
@@ -833,7 +807,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("%s\n", arg.as.b ? "true" : "false");
|
||||
printf("%b\n", arg.as.b);
|
||||
else if (arg.type == FZL_TYPE_NULL)
|
||||
printf("<null>\n");
|
||||
else if (arg.type == FZL_TYPE_OBJECT)
|
||||
@@ -842,7 +816,7 @@ int fzl_vm_run(fzl_vm_t *vm)
|
||||
else if (fn_id == FZL_BUILTIN_EXIT)
|
||||
{
|
||||
fzl_value_t arg = vm->dstack[--vm->dtop];
|
||||
return arg.as.i;
|
||||
exit(arg.as.i);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1011,9 +985,6 @@ 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,6 +7,8 @@
|
||||
#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));
|
||||
|
||||
+3
-11
@@ -17,6 +17,7 @@ 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
|
||||
@@ -33,7 +34,7 @@ run_args_t *parse_args(int argc, char **argv)
|
||||
args->help = false;
|
||||
args->debug = false;
|
||||
|
||||
for (int i = 0; i < argc; i++)
|
||||
for (size_t i = 0; i < argc; i++)
|
||||
{
|
||||
if (argv[i][0] != '-')
|
||||
continue;
|
||||
@@ -49,7 +50,6 @@ 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,7 +58,6 @@ 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;
|
||||
}
|
||||
|
||||
@@ -75,7 +74,6 @@ int main(int argc, char **argv)
|
||||
else if (args->help)
|
||||
{
|
||||
print_hint();
|
||||
free(args);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -83,7 +81,6 @@ int main(int argc, char **argv)
|
||||
if (!vm)
|
||||
{
|
||||
printf("Error: %s\n", fzl_vm_geterror());
|
||||
free(args);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -94,12 +91,7 @@ int main(int argc, char **argv)
|
||||
int result = fzl_vm_run(vm);
|
||||
if (result != 0)
|
||||
{
|
||||
char *err = fzl_vm_geterror();
|
||||
if (err && err[0])
|
||||
printf("Error: %s\n", err);
|
||||
|
||||
free(args);
|
||||
fzl_freevm(vm);
|
||||
printf("Error: %s\n", fzl_vm_geterror());
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user