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

feat: implement objects moving and borrowing

Browse Source
This commit is contained in:
samsonium
2026-10-17 19:24:03 +03:00
parent 2d307d9d42
commit 645120eda6
10 changed files with 432 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/fzl_walker.c
+126 -36
View File
@@ -65,6 +65,9 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
// Convert type token to `fzl_type_t`
const fzl_type_t tok_to_type(fzl_token_t *tok)
{
if (tok->type == FZL_TOKTYPE_NAME)
return FZL_TYPE_OBJECT;
if (strcmp((char *)tok->value, "i8") == 0)
return FZL_TYPE_INT8;
if (strcmp((char *)tok->value, "i16") == 0)
@@ -98,8 +101,14 @@ const fzl_type_t tok_to_type(fzl_token_t *tok)
return FZL_TYPE_NULL;
}
static bool is_compatible(fzl_type_t t1, fzl_type_t t2)
static bool is_compatible(fzl_type_t t1, fzl_type_t t2, char *c1, char *c2)
{
if (t1 == FZL_TYPE_OBJECT || t2 == FZL_TYPE_OBJECT)
{
return t1 == FZL_TYPE_OBJECT && t2 == FZL_TYPE_OBJECT &&
(strcmp(c1, c2) == 0);
}
if (t1 == t2)
return true;
@@ -369,6 +378,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
fzl_symtable_res_t putres =
fzl_symt_put(walker->syms[walker->sym_top - 1],
node->fn.name->value, fntype, walker->op_count);
if (putres != FZL_SYMTABLE_RESULT_OK)
{
if (putres == FZL_SYMTABLE_RESULT_EXISTS)
@@ -382,7 +392,23 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
"'%s': failed to store name '%s'", node->fn.name->filename,
(char *)node->fn.name->value);
return (fzl_walk_res_t){.error = true};
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
if (fntype == FZL_TYPE_OBJECT)
{
fzl_symtable_res_t updres =
fzl_symt_setobjclass(walker->syms[walker->sym_top - 1],
node->fn.name->value, node->fn.type->value);
if (updres != FZL_SYMTABLE_RESULT_OK)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': failed to assign object type to function return "
"type at %ld:%ld",
node->fn.type->filename, node->fn.type->ln,
node->fn.type->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
}
// NOTE: add sym_top limit check
@@ -430,7 +456,12 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
for (ssize_t i = walker->sym_top - 1; i >= lvl; i--)
fzl_freesymt(walker->syms[--walker->sym_top]);
current_res = (fzl_walk_res_t){.type = fntype, .error = false};
char *retclass = NULL;
if (fntype == FZL_TYPE_OBJECT && node->fn.type)
retclass = node->fn.type->value;
current_res = (fzl_walk_res_t){
.type = fntype, .error = false, .classname = retclass};
break;
}
@@ -445,14 +476,15 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
bool returning_object = false;
if (node->ret.value)
{
fzl_walk_res_t retres = walk(walker, node->ret.value);
if (retres.error)
return retres;
if (!is_compatible(retres.type,
tok_to_type(walker->ctx->fn->fn.type)))
if (!is_compatible(retres.type, tok_to_type(walker->ctx->fn->fn.type),
retres.classname, walker->ctx->fn->fn.type->value))
{
snprintf(
wlast_err, sizeof(wlast_err),
@@ -462,14 +494,23 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
current_res = (fzl_walk_res_t){.type = retres.type, .error = false};
if (retres.type == FZL_TYPE_OBJECT)
returning_object = true;
current_res = (fzl_walk_res_t){.type = retres.type,
.error = false,
.classname = retres.classname};
}
else
current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
for (size_t i = 0; i < (walker->sym_top - walker->ctx->initial_env_lvl);
i++)
{
if (returning_object)
push_op(walker, FZL_OPCODE_ESCAPE_OBJECT);
push_op(walker, FZL_OPCODE_RM_ENVTABLE);
}
push_op(walker, FZL_OPCODE_RET);
break;
}
@@ -500,7 +541,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
if (right.error)
return right;
if (!is_compatible(left.type, right.type))
if (!is_compatible(left.type, right.type, left.classname,
right.classname))
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': incompatible types at %ld:%ld", node->token->filename,
@@ -508,31 +550,72 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
switch (node->type)
if (left.type == FZL_TYPE_STRING && right.type == FZL_TYPE_STRING)
{
case FZL_NODETYPE_EQUAL:
push_op(walker, FZL_OPCODE_CMP_EQ);
break;
case FZL_NODETYPE_NEQUAL:
push_op(walker, FZL_OPCODE_CMP_NEQ);
break;
case FZL_NODETYPE_LESS:
push_op(walker, FZL_OPCODE_CMP_LT);
break;
case FZL_NODETYPE_LESS_EQUAL:
push_op(walker, FZL_OPCODE_CMP_LTEQ);
break;
case FZL_NODETYPE_GREATER:
push_op(walker, FZL_OPCODE_CMP_GT);
break;
case FZL_NODETYPE_GREATER_EQUAL:
push_op(walker, FZL_OPCODE_CMP_GTEQ);
break;
default:
break;
switch (node->type)
{
case FZL_NODETYPE_EQUAL:
push_op(walker, FZL_OPCODE_CMP_EQ_STR);
break;
case FZL_NODETYPE_NEQUAL:
push_op(walker, FZL_OPCODE_CMP_NEQ_STR);
break;
default:
snprintf(wlast_err, sizeof(wlast_err),
"'%s': unsupported strings operation at %ld:%ld",
node->token->filename, node->token->ln, node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
}
else if (left.type == FZL_TYPE_OBJECT && right.type == FZL_TYPE_OBJECT)
{
switch (node->type)
{
case FZL_NODETYPE_EQUAL:
push_op(walker, FZL_OPCODE_CMP_EQ_OBJ);
break;
case FZL_NODETYPE_NEQUAL:
push_op(walker, FZL_OPCODE_CMP_NEQ_OBJ);
break;
default:
snprintf(wlast_err, sizeof(wlast_err),
"'%s': unsupported object operation at %ld:%ld",
node->token->filename, node->token->ln, node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
}
else
{
switch (node->type)
{
case FZL_NODETYPE_EQUAL:
push_op(walker, FZL_OPCODE_CMP_EQ);
break;
case FZL_NODETYPE_NEQUAL:
push_op(walker, FZL_OPCODE_CMP_NEQ);
break;
case FZL_NODETYPE_LESS:
push_op(walker, FZL_OPCODE_CMP_LT);
break;
case FZL_NODETYPE_LESS_EQUAL:
push_op(walker, FZL_OPCODE_CMP_LTEQ);
break;
case FZL_NODETYPE_GREATER:
push_op(walker, FZL_OPCODE_CMP_GT);
break;
case FZL_NODETYPE_GREATER_EQUAL:
push_op(walker, FZL_OPCODE_CMP_GTEQ);
break;
default:
break;
}
}
current_res = (fzl_walk_res_t){.type = left.type, .error = false};
current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
break;
}
@@ -547,7 +630,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
if (right.error)
return right;
if (!is_compatible(left.type, right.type))
if (!is_compatible(left.type, right.type, left.classname,
right.classname))
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': incompatible types at %ld:%ld", node->token->filename,
@@ -560,7 +644,7 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
else
push_op(walker, FZL_OPCODE_OR);
current_res = (fzl_walk_res_t){.type = left.type, .error = false};
current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
break;
}
@@ -717,7 +801,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
push_op(walker, FZL_OPCODE_CALL);
push_word(walker, res.ip);
current_res = (fzl_walk_res_t){.type = res.type, .error = false};
current_res = (fzl_walk_res_t){
.type = res.type, .error = false, .classname = res.classname};
}
else if (node->call.callee->type == FZL_NODETYPE_FIELD)
{
@@ -810,7 +895,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
push_op(walker, FZL_OPCODE_CALL);
push_word(walker, res.ip);
current_res = (fzl_walk_res_t){.type = res.type, .error = false};
current_res = (fzl_walk_res_t){
.type = res.type, .error = false, .classname = res.classname};
}
}
break;
@@ -972,7 +1058,9 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
push_op(walker, FZL_OPCODE_LOADCONST);
push_word(walker, const_n);
current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL,
.error = false,
.classname = node->var.type->value};
break;
}
@@ -1016,7 +1104,8 @@ 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 (!is_compatible(sym.type, rres.type))
if (!is_compatible(sym.type, rres.type, sym.classname,
rres.classname))
{
fzl_token_t *tok = node->binary_op.right->token;
snprintf(wlast_err, sizeof(wlast_err),
@@ -1091,7 +1180,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
current_res = (fzl_walk_res_t){.type = rres.type, .error = false};
current_res = (fzl_walk_res_t){
.type = rres.type, .error = false, .classname = rres.classname};
break;
}
}
src/vm/fzl_vm.c
+170 -2
View File
@@ -110,6 +110,43 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
return vm;
}
void print_object(fzl_vm_object_t *obj)
{
if (!obj)
{
printf("<null>\n");
return;
}
printf("obj<");
for (size_t i = 0; i < obj->values_count; i++)
{
fzl_value_t arg = obj->values[i];
if (i > 0)
printf(", ");
if (arg.type == FZL_TYPE_STRING)
printf("str(%s)", arg.as.s.value);
else if (arg.type == FZL_TYPE_CHAR)
printf("char(%c)", arg.as.c);
else if (arg.type == FZL_TYPE_INT)
printf("int(%ld)", arg.as.i);
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);
else if (arg.type == FZL_TYPE_NULL)
printf("<null>");
else if (arg.type == FZL_TYPE_OBJECT)
print_object(arg.as.obj);
else
printf("<unknown>");
}
printf(">\n");
}
int fzl_vm_run(fzl_vm_t *vm)
{
if (!vm)
@@ -125,6 +162,125 @@ int fzl_vm_run(fzl_vm_t *vm)
switch (opcode)
{
case FZL_OPCODE_CMP_EQ_STR:
{
if (vm->dtop < 2)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
return -1;
}
fzl_value_t left = vm->dstack[--vm->dtop];
fzl_value_t right = vm->dstack[--vm->dtop];
int result = strcmp(left.as.s.value, right.as.s.value);
vm->dstack[vm->dtop++] =
(fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = result == 0};
break;
}
case FZL_OPCODE_CMP_NEQ_STR:
{
if (vm->dtop < 2)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
return -1;
}
fzl_value_t left = vm->dstack[--vm->dtop];
fzl_value_t right = vm->dstack[--vm->dtop];
int result = strcmp(left.as.s.value, right.as.s.value);
vm->dstack[vm->dtop++] =
(fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = result != 0};
break;
}
case FZL_OPCODE_CMP_EQ_OBJ:
{
if (vm->dtop < 2)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
return -1;
}
fzl_value_t left = vm->dstack[--vm->dtop];
fzl_value_t right = vm->dstack[--vm->dtop];
vm->dstack[vm->dtop++] = (fzl_value_t){
.type = FZL_TYPE_BOOL, .as.b = &left.as.obj == &right.as.obj};
break;
}
case FZL_OPCODE_CMP_NEQ_OBJ:
{
if (vm->dtop < 2)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
return -1;
}
fzl_value_t left = vm->dstack[--vm->dtop];
fzl_value_t right = vm->dstack[--vm->dtop];
vm->dstack[vm->dtop++] = (fzl_value_t){
.type = FZL_TYPE_BOOL, .as.b = &left.as.obj != &right.as.obj};
break;
}
case FZL_OPCODE_ESCAPE_OBJECT:
{
if (vm->dtop < 1)
{
snprintf(last_err, sizeof(last_err),
"runtime error - missing value in data stack");
return -1;
}
fzl_value_t obj = vm->dstack[--vm->dtop];
if (obj.type != FZL_TYPE_OBJECT)
{
snprintf(last_err, sizeof(last_err),
"runtime error - cannot escape non-object type");
return -1;
}
fzl_vm_env_t *parent = vm->estack[vm->etop - 2];
fzl_vm_env_t *current = vm->estack[vm->etop - 1];
if (!parent || vm->etop < 2)
{
snprintf(last_err, sizeof(last_err),
"runtime error - cannot escape object from global env");
return -1;
}
bool found = false;
for (size_t i = 0; i < current->owned_objects_count; i++)
{
if (obj.as.obj == current->owned_objects[i])
{
found = true;
current->owned_objects[i] = NULL;
break;
}
}
if (found)
{
if (parent->owned_objects_remainder <= parent->owned_objects_count)
{
parent->owned_objects_remainder *= 2;
parent->owned_objects =
realloc(parent->owned_objects, parent->owned_objects_remainder *
sizeof(fzl_vm_object_t *));
}
parent->owned_objects[parent->owned_objects_count++] = obj.as.obj;
}
vm->dstack[vm->dtop++] = obj;
break;
}
case FZL_OPCODE_ALLOC_OBJECT:
{
uint64_t values_count = vm->ops[++vm->ip];
@@ -132,7 +288,17 @@ int fzl_vm_run(fzl_vm_t *vm)
obj->values = malloc(values_count * sizeof(fzl_value_t));
obj->values_count = values_count;
vm->objects[vm->objects_count++] = obj;
fzl_vm_env_t *current_env = vm->estack[vm->etop - 1];
if (current_env->owned_objects_remainder <=
current_env->owned_objects_count)
{
current_env->owned_objects_remainder *= 2;
current_env->owned_objects = realloc(
current_env->owned_objects,
current_env->owned_objects_remainder * sizeof(fzl_vm_object_t *));
}
current_env->owned_objects[current_env->owned_objects_count++] = obj;
vm->dstack[vm->dtop++] =
(fzl_value_t){.type = FZL_TYPE_OBJECT, .as.obj = obj};
break;
@@ -260,8 +426,8 @@ int fzl_vm_run(fzl_vm_t *vm)
return -1;
}
fzl_value_t rlt = vm->dstack[--vm->dtop];
fzl_value_t llt = vm->dstack[--vm->dtop];
fzl_value_t rlt = vm->dstack[--vm->dtop];
vm->dstack[vm->dtop++] =
(fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = llt.as.u < rlt.as.u};
break;
@@ -474,6 +640,8 @@ int fzl_vm_run(fzl_vm_t *vm)
printf("%b\n", arg.as.b);
else if (arg.type == FZL_TYPE_NULL)
printf("<null>\n");
else if (arg.type == FZL_TYPE_OBJECT)
print_object(arg.as.obj);
}
else
{
src/vm/fzl_vm_debug.c
+20
View File
@@ -20,6 +20,26 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
switch (vm->ops[i])
{
case FZL_OPCODE_CMP_EQ_STR:
printf("CMP_EQ_STR\n");
break;
case FZL_OPCODE_CMP_NEQ_STR:
printf("CMP_NEQ_STR\n");
break;
case FZL_OPCODE_CMP_EQ_OBJ:
printf("CMP_EQ_OBJ\n");
break;
case FZL_OPCODE_CMP_NEQ_OBJ:
printf("CMP_NEQ_OBJ\n");
break;
case FZL_OPCODE_ESCAPE_OBJECT:
printf("ESCAPE_OBJ\n");
break;
case FZL_OPCODE_ALLOC_OBJECT:
printf("ALLOC_OBJECT: %lu fields\n", vm->ops[++i]);
break;
src/vm/fzl_vm_env.c
+20
View File
@@ -1,3 +1,4 @@
#include "vm/fzl_vm_object.h"
#include <common/fzl_types.h>
#include <common/fzl_value.h>
#include <stdbool.h>
@@ -15,6 +16,11 @@ fzl_vm_env_t *fzl_mkenv()
env->size = 0;
env->table = malloc(env->remainder * sizeof(fzl_vm_env_entry_t));
env->owned_objects_remainder = 2;
env->owned_objects_count = 0;
env->owned_objects =
malloc(env->owned_objects_remainder * sizeof(fzl_vm_object_t *));
return env;
}
@@ -96,5 +102,19 @@ void fzl_freeenv(fzl_vm_env_t *env)
if (env->table)
free(env->table);
if (env->owned_objects)
{
for (size_t i = 0; i < env->owned_objects_count; i++)
{
if (!env->owned_objects[i])
continue;
free(env->owned_objects[i]->values);
free(env->owned_objects[i]);
}
free(env->owned_objects);
}
free(env);
}