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

feat: finished variables declaration / assign

Browse Source
This commit is contained in:
samsonium
2026-10-14 01:00:01 +03:00
parent 7e52c671aa
commit c0dc14a0c7
11 changed files with 419 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/fzl_walker.c
+128 -18
View File
@@ -5,6 +5,7 @@
#include <compiler/fzl_token.h>
#include <compiler/fzl_walker.h>
#include <compiler/utils/fzl_const_pool.h>
#include <compiler/utils/fzl_symtable.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
@@ -43,11 +44,63 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
walker->op_remainder = 2;
walker->ops = malloc(walker->op_remainder * sizeof(uint64_t));
walker->sym_top = 0;
walker->syms[walker->sym_top++] = fzl_mksymt();
if (!walker->syms[walker->sym_top - 1])
{
snprintf(wlast_err, sizeof(wlast_err), "failed to create global symtable");
return NULL;
}
return walker;
}
// --- Walking zone ---
// Convert type token to `fzl_type_t`
const fzl_type_t tok_to_type(fzl_token_t *tok)
{
if (strcmp((char *)tok->value, "i8") == 0)
return FZL_TYPE_INT8;
if (strcmp((char *)tok->value, "i16") == 0)
return FZL_TYPE_INT16;
if (strcmp((char *)tok->value, "i32") == 0)
return FZL_TYPE_INT32;
if (strcmp((char *)tok->value, "i64") == 0)
return FZL_TYPE_INT64;
if (strcmp((char *)tok->value, "u8") == 0)
return FZL_TYPE_UINT8;
if (strcmp((char *)tok->value, "u16") == 0)
return FZL_TYPE_UINT16;
if (strcmp((char *)tok->value, "u32") == 0)
return FZL_TYPE_UINT32;
if (strcmp((char *)tok->value, "u64") == 0)
return FZL_TYPE_UINT64;
if (strcmp((char *)tok->value, "int") == 0)
return FZL_TYPE_INT;
if (strcmp((char *)tok->value, "uint") == 0)
return FZL_TYPE_UINT;
if (strcmp((char *)tok->value, "bool") == 0)
return FZL_TYPE_BOOL;
if (strcmp((char *)tok->value, "str") == 0)
return FZL_TYPE_STRING;
if (strcmp((char *)tok->value, "char") == 0)
return FZL_TYPE_CHAR;
return FZL_TYPE_NULL;
}
static bool is_compatible(fzl_type_t t1, fzl_type_t t2)
{
if (t1 == t2)
return true;
return t1 >= FZL_TYPE_INT8 && t2 >= FZL_TYPE_INT8;
}
// Add const to consts table
size_t add_const(fzl_walker_t *walker, fzl_const_t c)
{
@@ -94,8 +147,6 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
if (!walker || !node)
return (fzl_walk_res_t){.error = true, .error_msg = "walker is null"};
push_op(walker, FZL_OPCODE_MK_ENVTABLE);
fzl_walk_res_t current_res;
while (node != NULL)
{
@@ -111,13 +162,28 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
.as.string.chars = node->token->value,
.as.string.length = node->token->value_sz});
fzl_sym_t sym;
bool exists = fzl_symt_get(walker->syms[walker->sym_top - 1],
node->token->value, &sym);
if (!exists)
{
snprintf(wlast_err, sizeof(wlast_err),
"cannot find symbol '%s' at %ld:%ld",
(char *)node->token->value, node->token->ln,
node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
push_op(walker, FZL_OPCODE_LOADCONST);
push_word(walker, n);
current_res = (fzl_walk_res_t){.type = FZL_TYPE_STRING, .error = false};
push_op(walker, FZL_OPCODE_LOOKUP_ENV);
current_res = (fzl_walk_res_t){.type = sym.type, .error = false};
break;
}
case FZL_NODETYPE_BLOCK:
push_op(walker, FZL_OPCODE_MK_ENVTABLE);
if (node->list.entry_count > 0)
for (size_t i = 0; i < node->list.entry_count; i++)
{
@@ -125,10 +191,11 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
if (res.error)
return res;
}
push_op(walker, FZL_OPCODE_RM_ENVTABLE);
break;
case FZL_NODETYPE_CALL:
if (node->list.entry_count > 0)
if (node->call.args_count > 0)
{
for (size_t i = 0; i < node->call.args_count; i++)
{
@@ -198,7 +265,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
if (rres.error)
return rres;
if (lres.type == FZL_TYPE_STRING)
if (lres.type < FZL_TYPE_INT8)
{
fzl_token_t *ltok = node->binary_op.left->token;
snprintf(wlast_err, sizeof(wlast_err),
@@ -207,7 +274,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};
}
if (rres.type == FZL_TYPE_STRING)
if (rres.type < FZL_TYPE_INT8)
{
fzl_token_t *rtok = node->binary_op.right->token;
snprintf(
@@ -250,7 +317,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
if (res.error)
return res;
if (res.type == FZL_TYPE_STRING)
if (res.type < FZL_TYPE_INT8)
{
fzl_token_t *tok = node->unary_op.operand->token;
snprintf(wlast_err, sizeof(wlast_err),
@@ -266,13 +333,22 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
case FZL_NODETYPE_DECLARATION:
{
fzl_walk_res_t rres = walk(walker, node->var.identifier);
if (rres.error)
return rres;
fzl_symtable_res_t res = fzl_symt_put(
walker->syms[walker->sym_top - 1],
node->var.identifier->token->value, tok_to_type(node->var.type));
fzl_token_t *id_tok = node->var.identifier->token;
size_t const_n = add_const(
walker, (fzl_const_t){.type = FZL_CONSTTYPE_STRING,
.as.string.chars = id_tok->value,
.as.string.length = id_tok->value_sz});
push_op(walker, FZL_OPCODE_LOADCONST);
push_word(walker, const_n);
push_op(walker, FZL_OPCODE_STORE);
// NOTE: ignoring type field for now
push_op(walker, FZL_OPCODE_LOADCONST);
push_word(walker, const_n);
current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
break;
@@ -280,16 +356,48 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
case FZL_NODETYPE_ASSIGN:
{
fzl_walk_res_t lres = walk(walker, node->binary_op.left);
if (lres.error)
return lres;
push_op(walker, FZL_OPCODE_LOOKUP_ENV);
fzl_walk_res_t rres = walk(walker, node->binary_op.right);
if (rres.error)
return rres;
if (node->binary_op.left->type == FZL_NODETYPE_DECLARATION)
{
fzl_walk_res_t lres = walk(walker, node->binary_op.left);
if (lres.error)
return lres;
}
else if (node->binary_op.left->type == FZL_NODETYPE_IDENTIFIER)
{
fzl_sym_t sym;
bool res = fzl_symt_get(walker->syms[walker->sym_top - 1],
node->binary_op.left->token->value, &sym);
if (!res) // NOTE: refactor this before implement blocks, fns, etc
{
fzl_token_t *tok = node->binary_op.left->token->value;
snprintf(wlast_err, sizeof(wlast_err),
"name '%s' is not exists at %ld:%ld", (char *)tok->value,
tok->ln, tok->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
if (!is_compatible(sym.type, rres.type))
{
fzl_token_t *tok = node->binary_op.right->token;
snprintf(wlast_err, sizeof(wlast_err),
"R-Value is not compatible with L-Value at %ld:%ld",
tok->ln, tok->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
size_t const_n = add_const(
walker, (fzl_const_t){.type = FZL_CONSTTYPE_STRING,
.as.string.chars = sym.name,
.as.string.length =
node->binary_op.left->token->value_sz});
push_op(walker, FZL_OPCODE_LOADCONST);
push_word(walker, const_n);
}
push_op(walker, FZL_OPCODE_WRITE);
current_res = (fzl_walk_res_t){.type = rres.type, .error = false};
break;
@@ -311,7 +419,9 @@ int fzl_walk(fzl_walker_t *walker)
return -1;
}
push_op(walker, FZL_OPCODE_MK_ENVTABLE);
fzl_walk_res_t result = walk(walker, walker->root);
push_op(walker, FZL_OPCODE_RM_ENVTABLE);
if (result.error && !wlast_err[0])
snprintf(wlast_err, sizeof(wlast_err), "%s", result.error_msg);
src/compiler/utils/fzl_symtable.c
+68
View File
@@ -0,0 +1,68 @@
#include <compiler/utils/fzl_symtable.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
fzl_symtable_t *fzl_mksymt()
{
fzl_symtable_t *tbl = malloc(sizeof(fzl_symtable_t));
if (!tbl)
return NULL;
tbl->remainder = 2;
tbl->size = 0;
tbl->symbols = malloc(tbl->remainder * sizeof(fzl_sym_t));
if (!tbl->symbols)
return NULL;
return tbl;
}
fzl_symtable_res_t fzl_symt_put(fzl_symtable_t *symt, char *name,
fzl_type_t type)
{
if (!symt)
return FZL_SYMTABLE_RESULT_ERR;
for (size_t i = 0; i < symt->size; i++)
if (strcmp(symt->symbols[i].name, name) == 0)
return FZL_SYMTABLE_RESULT_EXISTS;
if (symt->remainder <= symt->size)
{
symt->remainder *= 2;
symt->symbols = realloc(symt->symbols, symt->remainder * sizeof(fzl_sym_t));
}
symt->symbols[symt->size++] = (fzl_sym_t){.name = name, .type = type};
return FZL_SYMTABLE_RESULT_OK;
}
bool fzl_symt_get(fzl_symtable_t *symt, char *name, fzl_sym_t *res)
{
if (!symt)
return false;
for (size_t i = 0; i < symt->size; i++)
{
if (strcmp(symt->symbols[i].name, name) == 0)
{
*res = symt->symbols[i];
return true;
}
}
return false;
}
void fzl_freesymt(fzl_symtable_t *symt)
{
if (!symt)
return;
if (symt->symbols)
free(symt->symbols);
free(symt);
}