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/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);
}