samsonium/fz-lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Merge branch 'master' into docs

Browse Source
This commit is contained in:
samsonium
2026-10-19 20:11:53 +03:00
parent d22b4009b0 1e518c4c82
commit 5e58ea1796
14 changed files with 298 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+7 -1
View File
@@ -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)
include/compiler/utils/fzl_const_pool.h
+4 -4
View File
@@ -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
-1
View File
@@ -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
+161 -94
View File
@@ -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 *right = NULL;
fzl_node_t *left = parse_primary(parser);
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);
memcpy(&new_args[1], new_args,
(node->fn.args_count - 1) * sizeof(fzl_node_t *));
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;
}
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);
if (node->fn.args_count > 1)
memmove(&new_args[1], new_args,
(node->fn.args_count - 1) * sizeof(fzl_node_t *));
fzl_node_t *this_id = fzl_mknode(FZL_NODETYPE_IDENTIFIER, &this_tok);
fzl_node_t *this_dec = fzl_mknode(FZL_NODETYPE_DECLARATION, name);
this_dec->var.type = name;
this_dec->var.identifier = this_id;
new_args[0] = this_dec;
node->fn.args = new_args;
methods[mcount++] = node;
}
else
@@ -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,
"null", 4, last_known_tok->filename);
type = &null_tok;
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)
{
for (size_t i = 0; i < root->list.entry_count; i++)
if (root->list.entries[i])
fzl_freeast(root->list.entries[i]);
case FZL_NODETYPE_IDENTIFIER:
case FZL_NODETYPE_LITERAL:
break;
free(root->list.entries);
}
}
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]);
case FZL_NODETYPE_BLOCK:
if (root->list.entries)
{
for (size_t i = 0; i < root->list.entry_count; i++)
if (root->list.entries[i])
fzl_freeast(root->list.entries[i]);
free(root->call.args);
}
}
else if (root->type == FZL_NODETYPE_ADD || root->type == FZL_NODETYPE_SUB ||
root->type == FZL_NODETYPE_MUL || root->type == FZL_NODETYPE_DIV ||
root->type == FZL_NODETYPE_POW || root->type == FZL_NODETYPE_MOD)
{
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);
free(root->list.entries);
}
break;
if (root->class.methods_count)
for (size_t i = 0; i < root->class.methods_count; i++)
fzl_freenode(root->class.methods[i]);
free(root->class.methods);
}
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);
case FZL_NODETYPE_CALL:
if (root->call.callee)
fzl_freeast(root->call.callee);
if (root->call.args_count)
{
for (size_t i = 0; i < root->call.args_count; i++)
if (root->call.args[i])
fzl_freeast(root->call.args[i]);
}
if (root->call.args)
free(root->call.args);
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;
free(root);
fzl_node_t *next = root->next;
fzl_freenode(root);
root = next;
}
}
src/compiler/fzl_reader.c
+8 -7
View File
@@ -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
+9 -4
View File
@@ -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);
memcpy(valholder, value, value_len);
valholder[value_len] = '\0';
char *valholder = NULL;
if (value && value_len > 0)
{
valholder = malloc(value_len + 1);
memcpy(valholder, value, value_len);
valholder[value_len] = '\0';
}
fzl_token_t *token = malloc(sizeof(fzl_token_t));
token->type = type;
token->ln = line;
token->cn = col;
token->store_value = value_len > 0;
token->store_value = (valholder != NULL);
token->value = valholder;
token->value_sz = value_len;
token->filename = filename;
src/compiler/fzl_walker.c
+7 -5
View File
@@ -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
+28
View File
@@ -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
+25 -25
View File
@@ -11,31 +11,31 @@ bool fzl_consts_equal(fzl_const_t a, fzl_const_t b)
switch (a.type)
{
case FZL_CONSTTYPE_STRING:
{
if (a.as.string.length != b.as.string.length)
return false;
case FZL_CONSTTYPE_STRING:
{
if (a.as.string.length != b.as.string.length)
return false;
return memcmp(a.as.string.chars, b.as.string.chars, a.as.string.length) ==
0;
}
return memcmp(a.as.string.chars, b.as.string.chars, a.as.string.length) ==
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:
data = (const uint8_t *)c.as.string.chars;
size = c.as.string.length;
break;
case FZL_CONSTTYPE_STRING:
data = (const uint8_t *)c.as.string.chars;
size = c.as.string.length;
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];
uint32_t hash = fzl_hash_const(c);
fzl_const_t c = pool->array[index_in_pool];
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
+3 -2
View File
@@ -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
+2 -2
View File
@@ -36,7 +36,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] != '-')
@@ -112,7 +112,7 @@ 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);
src/vm/fzl_vm.c
+33 -4
View File
@@ -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
-2
View File
@@ -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
+11 -2
View File
@@ -34,7 +34,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 +50,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 +59,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 +76,7 @@ int main(int argc, char **argv)
else if (args->help)
{
print_hint();
free(args);
return 0;
}
@@ -81,6 +84,7 @@ int main(int argc, char **argv)
if (!vm)
{
printf("Error: %s\n", fzl_vm_geterror());
free(args);
return -1;
}
@@ -91,7 +95,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;
}
}