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

RAII #2

Merged
samsonium merged 14 commits from impl-dealloc into master 2026-10-18 18:00:04 +00:00
Conversation 0 Commits 14 Files Changed 19
+860 -159
19 changed files with 860 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gdbinit
+7 -10
View File
@@ -2,17 +2,14 @@ skip peek
skip consume
skip next
skip is
skip fzl_mknode
skip fzl_mktoken
skip fzl_symt_put
skip fzl_symt_get
skip -rfunction fzl_mk*
skip -rfunction fzl_free*
skip -rfunction fzl_symt*
skip add_const
skip push_op
skip push_word
skip fzl_mkenv
skip fzl_freeenv
skip fzl_env_lookup
skip fzl_env_contains
skip fzl_env_storevalue
skip fzl_env_writevalue
skip -rfunction fzl_env*
skip tok_to_type
skip nest_ctx
skip fin_ctx
CMakeLists.txt
+24
View File
@@ -70,6 +70,18 @@ add_test(
NAME compile_class
COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/class.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/class.fzs"
)
add_test(
NAME compile_raii
COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/raii.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/raii.fzs"
)
add_test(
NAME compile_borrow
COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/borrow.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/borrow.fzs"
)
add_test(
NAME compile_hard_1
COMMAND fzc -o "${CMAKE_CURRENT_BINARY_DIR}/hard-1.fzb" "${CMAKE_CURRENT_SOURCE_DIR}/exl/hard-1.fzs"
)
set_tests_properties(compile_problematic_hw PROPERTIES WILL_FAIL TRUE)
@@ -109,4 +121,16 @@ add_test(
NAME runtime_class
COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/class.fzb"
)
add_test(
NAME runtime_raii
COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/raii.fzb"
)
add_test(
NAME runtime_borrow
COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/borrow.fzb"
)
add_test(
NAME runtime_hard_1
COMMAND fz "${CMAKE_CURRENT_BINARY_DIR}/hard-1.fzb"
)
exl/borrow.fzs
+46
View File
@@ -0,0 +1,46 @@
class A
{
uint some;
}
fn doSome(A a) A
{
// NOTE: section below won't change `a.some` value
if (a.some < 1)
{
a.some = 1;
return a;
}
return a;
}
fn doSomeNew() A
{
if (1 == 1)
{
return new A;
}
}
A a = new A;
a.some = 0;
if (a.some != 0)
{
printline("Test failed (first a.some != 0)");
exit(1);
}
else printline(a);
a = doSome(a);
if (a.some != 1)
{
printline("Test failed (2nd a.some != 1)");
exit(1);
}
else printline(a);
A b = doSomeNew();
printline(b);
exl/class.fzs
+5 -1
View File
@@ -28,5 +28,9 @@ printline(obj.y);
if (obj.x == 10 && obj.y == 10)
printline("Test passed");
else printline("Test failed");
else
{
printline("Test failed");
exit(1);
}
exl/conditions.fzs
+4
View File
@@ -1,13 +1,17 @@
bool flag = true;
if (!flag)
{
printline("buhhh, flag is not true");
exit(1);
}
else if (2 + 2 >= 4)
{
printline ("two plus two is four");
}
else {
printline("gotcha");
exit(1);
}
{
exl/fn.fzs
+10 -2
View File
@@ -15,10 +15,18 @@ printline("Test #1: fibonacci");
int result = fib(7);
if (result == 13)
printline("Recurse test passed");
else printline("Recurse test failed");
else
{
printline("Recurse test failed");
exit(1);
}
printline("Test #2: sum");
if (sum(2, 2) == 4)
printline("Sum test passed");
else printline("Sum test failed");
else
{
printline("Sum test failed");
exit(1);
}
exl/hard-1.fzs
+66
View File
@@ -0,0 +1,66 @@
class Node
{
int value;
Node next;
fn append(int val) Node
{
if (this.next == null)
{
Node tail = new Node;
tail.value = val;
tail.next = null;
this.next = tail;
return this;
}
this.next = this.next.append(val);
return this;
}
fn sum() int
{
if (this.next == null)
return this.value;
return this.value + this.next.sum();
}
fn printList()
{
printline(this.value);
if (this.next != null)
this.next.printList();
}
}
fn createList(int count) Node
{
if (count <= 0)
return null;
Node head = new Node;
head.value = count;
head.next = createList(count - 1);
return head;
}
printline("===== Test 1: factory & recursive escaping =====");
Node list = createList(3);
printline("Elements:");
list.printList();
printline("===== Test 2: mutation & methods =====");
list = list.append(10);
int total = list.sum();
printline("Sum of elements:");
printline(total);
if (total == 16)
printline("Tests passed!");
else
{
printline("Tests failed");
exit(1);
}
exl/raii.fzs
+46
View File
@@ -0,0 +1,46 @@
class Animal
{
str type;
str name;
int age;
fn copy() Animal
{
Animal cp = new Animal;
cp.type = this.type;
cp.name = this.name;
cp.age = this.age;
return cp;
}
}
Animal a = new Animal;
a.type = "Cow";
a.name = "Buryatka";
a.age = 5;
Animal b = a.copy();
b.name = "Gavryusha";
b.age = 10;
printline(a);
printline(b);
printline("Types are same:");
printline(a.type == b.type);
printline("Names are NOT the same");
printline(a.name != b.name);
printline("1st age less than 2nd");
printline(a.age < b.age);
if (a.type == b.type && a.name != b.name && a.age < b.age)
printline("Test passed");
else
{
printline("Test failed");
exit(1);
}
include/common/fzl_builtins.h
+2 -1
View File
@@ -3,7 +3,8 @@
typedef enum
{
FZL_BUILTIN_PRINTLINE // Print message in arg with newline at end
FZL_BUILTIN_PRINTLINE, // Print message in arg with newline at end
FZL_BUILTIN_EXIT, // Exit program with code specified in arg
} fzl_builtin_t;
#endif // FZL_BUILTINS_H
include/common/fzl_opcodes.h
+11 -3
View File
@@ -21,9 +21,11 @@ typedef enum
FZL_OPCODE_CALL = 0xF30001, // Call function
FZL_OPCODE_RET = 0xF30002, // Return from function
FZL_OPCODE_ALLOC_OBJECT = 0xFA0001, // Allocate N slots
FZL_OPCODE_GET_FIELD = 0xFA0002, // Get field N of an object at dstack
FZL_OPCODE_SET_FIELD = 0xFA0003, // Set field N of an object at dstack
FZL_OPCODE_ALLOC_OBJECT = 0xFA0001, // Allocate N slots
FZL_OPCODE_GET_FIELD = 0xFA0002, // Get field N of an object at dstack
FZL_OPCODE_SET_FIELD = 0xFA0003, // Set field N of an object at dstack
FZL_OPCODE_ESCAPE_OBJECT = 0xFA0004, // Make parent envtable as owner
FZL_OPCODE_DEREFERENCE = 0xFA0005, // Dereference address
FZL_OPCODE_ADD = 0xA00001, // Sum two numbers in dstack
FZL_OPCODE_SUB = 0xA00002, // Subract two numbers in dstack
@@ -40,6 +42,12 @@ typedef enum
FZL_OPCODE_CMP_GT = 0xB00005, // Greater than
FZL_OPCODE_CMP_GTEQ = 0xB00006, // Greater than or equal
FZL_OPCODE_CMP_EQ_STR = 0xB10001, // Strings equality
FZL_OPCODE_CMP_NEQ_STR = 0xB10002, // Strings non-equality
FZL_OPCODE_CMP_EQ_OBJ = 0xB20001, // Objects equality (by pointer)
FZL_OPCODE_CMP_NEQ_OBJ = 0xB20002, // Objects non-equality (by pointer)
FZL_OPCODE_AND = 0xC00001, // A && B
FZL_OPCODE_OR = 0xC00002, // A || B
include/compiler/fzl_token.h
+1
View File
@@ -34,6 +34,7 @@ typedef enum
FZL_TOKTYPE_STR_LITERAL, // ""
FZL_TOKTYPE_NUM_LITERAL, // 123
FZL_TOKTYPE_BOOL_LITERAL, // true
FZL_TOKTYPE_NULL_LITERAL, // null
FZL_TOKTYPE_DAMPERSAND, // &&
FZL_TOKTYPE_DVBAR, // ||
include/vm/fzl_vm.h
-3
View File
@@ -30,9 +30,6 @@ typedef struct
// Environment stack
fzl_vm_env_t *estack[256];
size_t etop;
fzl_vm_object_t *objects[256];
size_t objects_count;
} fzl_vm_t;
// Allocate FZL VM
include/vm/fzl_vm_env.h
+5
View File
@@ -4,6 +4,7 @@
#include <common/fzl_value.h>
#include <stdbool.h>
#include <stddef.h>
#include <vm/fzl_vm_object.h>
typedef enum
{
@@ -27,6 +28,10 @@ typedef struct
size_t remainder;
fzl_vm_env_entry_t *table;
fzl_vm_object_t **owned_objects;
size_t owned_objects_remainder;
size_t owned_objects_count;
} fzl_vm_env_t;
// Allocate env table
src/compiler/fzl_parser.c
+5 -12
View File
@@ -140,17 +140,10 @@ fzl_node_t *parse_primary(fzl_parser_t *parser)
if (!parser || !peek(parser))
return NULL;
if (is(parser, FZL_TOKTYPE_STR_LITERAL))
{
fzl_token_t *tok = consume(parser);
return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
}
else if (is(parser, FZL_TOKTYPE_NUM_LITERAL))
{
fzl_token_t *tok = consume(parser);
return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
}
else if (is(parser, FZL_TOKTYPE_BOOL_LITERAL))
if (is(parser, FZL_TOKTYPE_STR_LITERAL) ||
is(parser, FZL_TOKTYPE_NUM_LITERAL) ||
is(parser, FZL_TOKTYPE_BOOL_LITERAL) ||
is(parser, FZL_TOKTYPE_NULL_LITERAL))
{
fzl_token_t *tok = consume(parser);
return fzl_mknode(FZL_NODETYPE_LITERAL, tok);
@@ -822,7 +815,7 @@ fzl_node_t *parse_function(fzl_parser_t *parser)
return NULL;
}
fzl_token_t *type;
fzl_token_t *type = NULL;
if (is(parser, FZL_TOKTYPE_TYPE) || is(parser, FZL_TOKTYPE_NAME))
type = consume(parser);
src/compiler/fzl_reader.c
+4 -1
View File
@@ -88,13 +88,16 @@ fzl_token_t *parse_name(fzl_reader_t *reader)
else if (strcmp(value, "true") == 0 || strcmp(value, "false") == 0)
tok = fzl_mktoken(FZL_TOKTYPE_BOOL_LITERAL, l.line, l.col, value, size,
l.filename);
else if (strcmp(value, "null") == 0)
tok = fzl_mktoken(FZL_TOKTYPE_NULL_LITERAL, l.line, l.col, value, size,
l.filename);
else if (strcmp(value, "str") == 0 || strcmp(value, "char") == 0 ||
strcmp(value, "bool") == 0 || strcmp(value, "uint") == 0 ||
strcmp(value, "int") == 0 || strcmp(value, "i8") == 0 ||
strcmp(value, "i16") == 0 || strcmp(value, "i32") == 0 ||
strcmp(value, "i64") == 0 || strcmp(value, "u8") == 0 ||
strcmp(value, "u16") == 0 || strcmp(value, "u32") == 0 ||
strcmp(value, "u64") == 0 || strcmp(value, "null") == 0)
strcmp(value, "u64") == 0)
tok = fzl_mktoken(FZL_TOKTYPE_TYPE, l.line, l.col, value, size, l.filename);
else
tok = fzl_mktoken(FZL_TOKTYPE_NAME, l.line, l.col, value, size, l.filename);
src/compiler/fzl_walker.c
+212 -107
View File
@@ -14,6 +14,7 @@
#include <stdlib.h>
#include <string.h>
char *null_name = "<null>";
char wlast_err[256];
fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
@@ -65,6 +66,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 +102,17 @@ 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)
{
bool classes_compatible = strcmp(c1, c2) == 0 ||
strcmp(c1, null_name) == 0 ||
strcmp(c2, null_name) == 0;
return t1 == FZL_TYPE_OBJECT && t2 == FZL_TYPE_OBJECT && classes_compatible;
}
if (t1 == t2)
return true;
@@ -281,44 +294,34 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
case FZL_NODETYPE_FIELD:
{
fzl_sym_t sym;
bool exists = false;
for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
if ((exists = fzl_symt_get(walker->syms[i],
node->memb.parent->token->value, &sym)))
break;
fzl_walk_res_t parent_res = walk(walker, node->memb.parent);
if (parent_res.error)
return parent_res;
if (!exists)
if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': cannot find symbol '%s' at %ld:%ld",
node->token->filename, (char *)node->token->value,
node->token->ln, node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
if (!sym.classname)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': '%s' is not an object (at %ld:%ld)",
node->token->filename, sym.name, node->token->ln,
node->token->cn);
fzl_token_t *tok = node->memb.parent->token;
snprintf(
wlast_err, sizeof(wlast_err),
"'%s': cannot access field '%s' on non-object type at %ld:%ld",
tok->filename, (char *)node->memb.field->token->value, tok->ln,
tok->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
fzl_ctable_t *ct = NULL;
for (size_t i = 0; i < walker->classes_count; i++)
{
if (strcmp(sym.classname, walker->classes[i]->name) == 0)
if (strcmp(parent_res.classname, walker->classes[i]->name) == 0)
{
ct = walker->classes[i];
break;
}
}
fzl_token_t *tok = node->memb.parent->token;
if (!ct)
{
fzl_token_t *tok = node->memb.parent->token;
snprintf(wlast_err, sizeof(wlast_err),
"'%s': access to unknown class '%s' at %ld:%ld",
tok->filename, (char *)tok->value, tok->ln, tok->cn);
@@ -342,20 +345,17 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': cannot find field '%s' in class '%s' at %ld:%ld",
ftok->filename, (char *)ftok->value, (char *)tok->value,
ftok->filename, (char *)ftok->value, parent_res.classname,
ftok->ln, ftok->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
fzl_walk_res_t parent_res = walk(walker, node->memb.parent);
if (parent_res.error)
return parent_res;
push_op(walker, FZL_OPCODE_GET_FIELD);
push_word(walker, ctf.slot_index);
current_res = (fzl_walk_res_t){
.type = ctf.type, .error = false, .classname = sym.classname};
current_res = (fzl_walk_res_t){.type = ctf.type,
.error = false,
.classname = parent_res.classname};
break;
}
@@ -369,6 +369,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 +383,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 +447,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 +467,16 @@ 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)))
fzl_node_t *fn_node = walker->ctx->fn;
if (!is_compatible(retres.type, tok_to_type(fn_node->fn.type),
retres.classname, walker->ctx->fn->fn.type->value))
{
snprintf(
wlast_err, sizeof(wlast_err),
@@ -462,14 +486,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 +533,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 +542,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 +622,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 +636,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;
}
@@ -678,6 +754,30 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
}
current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
}
else if (strcmp(node->token->value, "exit") == 0)
{
if (node->call.args_count > 0)
{
for (size_t i = 0; i < node->call.args_count; i++)
{
fzl_walk_res_t res = walk(walker, node->call.args[i]);
if (res.error)
return res;
}
push_op(walker, FZL_OPCODE_CALL_BUILTIN);
push_word(walker, FZL_BUILTIN_EXIT);
if (node->call.args_count < 1)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': 'exit' call with zero arguments at %ld:%ld",
node->token->filename, node->token->ln, node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
current_res =
(fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
}
}
else
{
if (node->call.callee->type == FZL_NODETYPE_IDENTIFIER)
@@ -702,8 +802,9 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
if (!found)
{
snprintf(wlast_err, sizeof(wlast_err),
"call to unknown function '%s'",
(char *)node->token->value);
"'%s': call to unknown function '%s' at %ld:%ld",
node->token->filename, (char *)node->token->value,
node->token->ln, node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
@@ -717,85 +818,74 @@ 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)
{
fzl_node_t *parent_node = node->call.callee->memb.parent;
fzl_node_t *method_node = node->call.callee->memb.field;
fzl_sym_t res;
bool found = false;
for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
if ((found = fzl_symt_get(walker->syms[i],
parent_node->token->value, &res)))
break;
fzl_walk_res_t parent_res = walk(walker, parent_node);
if (parent_res.error)
return parent_res;
if (!found)
if (parent_res.type != FZL_TYPE_OBJECT || !parent_res.classname)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': access to unknown object '%s' at %ld:%ld",
node->token->filename, (char *)parent_node->token->value,
node->token->ln, node->token->cn);
"'%s': cannot call method on non-object type at %ld:%ld",
parent_node->token->filename, parent_node->token->ln,
parent_node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
if (res.type != FZL_TYPE_OBJECT || !res.classname)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': name '%s' is not an object (at %ld:%ld)",
parent_node->token->filename,
(char *)parent_node->token->value,
parent_node->token->ln, parent_node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
found = false;
char *classname = parent_res.classname;
bool class_exists = false;
for (size_t i = 0; i < walker->classes_count; i++)
{
if (strcmp(walker->classes[i]->name, res.classname) == 0)
if (strcmp(classname, walker->classes[i]->name) == 0)
{
found = true;
class_exists = true;
break;
}
}
if (!found)
if (!class_exists)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': class '%s' not found at %ld:%ld",
node->token->filename, res.classname, node->token->ln,
node->token->cn);
"'%s': class '%s' not found (at %ld:%ld)",
parent_node->token->filename, classname,
parent_node->token->ln, parent_node->token->cn);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
char *classname = res.classname;
size_t classlen = strlen(res.classname);
size_t fnlen = strlen(node->call.callee->token->value);
size_t classlen = strlen(classname);
size_t fnlen = strlen(method_node->token->value);
char *methodname = malloc(classlen + fnlen + 2);
strcpy(methodname, res.classname);
strcpy(methodname, classname);
strcpy((methodname + classlen + 1),
node->call.callee->token->value);
methodname[classlen] = '_';
methodname[classlen + fnlen + 1] = 0;
found = false;
fzl_sym_t fn_sym;
bool found_method = false;
for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
if ((found = fzl_symt_get(walker->syms[i], methodname, &res)))
if ((found_method =
fzl_symt_get(walker->syms[i], methodname, &fn_sym)))
break;
if (!found)
if (!found_method)
{
snprintf(wlast_err, sizeof(wlast_err),
"'%s': class '%s' has no method '%s' at %ld:%ld",
node->token->filename, classname,
(char *)node->call.callee->token->value, node->token->ln,
node->token->cn);
free(methodname);
return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
}
fzl_walk_res_t parent = walk(walker, parent_node);
if (parent.error)
return parent;
free(methodname);
if (node->call.args_count > 0)
{
@@ -808,9 +898,11 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
}
push_op(walker, FZL_OPCODE_CALL);
push_word(walker, res.ip);
push_word(walker, fn_sym.ip);
current_res = (fzl_walk_res_t){.type = res.type, .error = false};
current_res = (fzl_walk_res_t){.type = fn_sym.type,
.error = false,
.classname = fn_sym.classname};
}
}
break;
@@ -845,6 +937,15 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
push_word(walker, val);
current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
}
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);
current_res = (fzl_walk_res_t){
.type = FZL_TYPE_OBJECT, .error = false, .classname = null_name};
}
break;
case FZL_NODETYPE_ADD:
@@ -972,7 +1073,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;
}
@@ -1009,14 +1112,15 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
if (!found)
{
fzl_token_t *tok = node->binary_op.left->token->value;
fzl_token_t *tok = node->binary_op.left->token;
snprintf(wlast_err, sizeof(wlast_err),
"'%s': name '%s' is not exists at %ld:%ld", tok->filename,
(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))
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 +1195,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
+366 -19
View File
@@ -25,20 +25,18 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
return NULL;
}
vm->consts = NULL;
vm->consts_count = 0;
vm->ops = NULL;
vm->ops_count = 0;
vm->ip = 0;
vm->dtop = 0;
vm->ctop = 0;
vm->etop = 0;
vm->objects_count = 0;
vm->consts = NULL;
vm->consts_count = 0;
vm->ops = NULL;
vm->ops_count = 0;
vm->ip = 0;
vm->dtop = 0;
vm->ctop = 0;
vm->etop = 0;
memset(vm->dstack, 0, sizeof(vm->dstack));
memset(vm->cstack, 0, sizeof(vm->cstack));
memset(vm->estack, 0, sizeof(vm->estack));
memset(vm->objects, 0, sizeof(vm->objects));
FILE *fd = fopen(filepath, "rb");
if (!fd)
@@ -110,6 +108,162 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
return vm;
}
// Escape objects with nested objects check
static void escape_recursive(fzl_vm_env_t *current, fzl_vm_env_t *parent,
fzl_vm_object_t *obj)
{
if (!current || !parent || !obj)
return;
bool found_in_current = false;
for (size_t i = 0; i < current->owned_objects_count; i++)
{
if (current->owned_objects[i] == obj)
{
current->owned_objects[i] = NULL;
found_in_current = true;
break;
}
}
if (found_in_current)
{
bool found_in_parent = false;
for (size_t i = 0; i < parent->owned_objects_count; i++)
{
if (parent->owned_objects[i] == obj)
{
found_in_parent = true;
break;
}
}
if (!found_in_parent)
{
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;
}
}
for (size_t i = 0; i < obj->values_count; i++)
{
if (obj->values[i].type == FZL_TYPE_OBJECT && obj->values[i].as.obj != NULL)
escape_recursive(current, parent, obj->values[i].as.obj);
}
}
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");
}
void print_err_data(fzl_vm_t *vm)
{
printf("===== ERROR =====\n");
printf("> Caused on IP: %zu\n", vm->ip);
printf("\n> Data stack:\n");
if (vm->dtop > 0)
{
for (ssize_t i = vm->dtop - 1; i >= 0; i--)
{
printf("\t> [%d] ", vm->dstack[i].type);
switch (vm->dstack[i].type)
{
case FZL_TYPE_OBJECT:
printf("ref: %p\n", vm->dstack[i].as.obj);
break;
case FZL_TYPE_STRING:
printf("str: '%s'\n", vm->dstack[i].as.s.value);
break;
case FZL_TYPE_NULL:
printf("<null>\n");
break;
default:
printf("%lu\n", vm->dstack[i].as.u);
break;
}
}
}
else
{
printf("\tEmpty\n");
}
printf("\n> Environments:\n");
for (ssize_t i = vm->etop - 1; i >= 0; i--)
{
fzl_vm_env_t *env = vm->estack[i];
printf("\t> [%zd] %p:\n", i, env);
printf("\t\t> Owned objects (%zu/%zu):\n", env->owned_objects_count,
env->owned_objects_remainder);
for (size_t j = 0; j < env->owned_objects_count; j++)
printf("\t\t\t> ref: %p (entries: %zu)\n", env->owned_objects[j],
env->owned_objects[j]->values_count);
printf("\t\t> Local entries (%zu/%zu):\n", env->size, env->remainder);
for (size_t j = 0; j < env->size; j++)
{
switch (env->table[j].value.type)
{
case FZL_TYPE_OBJECT:
printf("\t\t\t> [%d] %s = ref %p\n", env->table[j].value.type,
env->table[j].name, env->table[j].value.as.obj);
break;
default:
printf("\t\t\t> [%d] %s = %lu\n", env->table[j].value.type,
env->table[j].name, env->table[j].value.as.u);
break;
}
}
}
printf("\n> Call stack:\n");
for (ssize_t i = vm->ctop - 1; i >= 0; i--)
printf("\t> [%zd] %lu\n", i, vm->cstack[i]);
}
int fzl_vm_run(fzl_vm_t *vm)
{
if (!vm)
@@ -125,6 +279,141 @@ int fzl_vm_run(fzl_vm_t *vm)
switch (opcode)
{
case FZL_OPCODE_DEREFERENCE:
{
if (vm->dtop < 1)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected value in data stack");
print_err_data(vm);
return -1;
}
fzl_value_t addr = vm->dstack[--vm->dtop];
if (addr.type < FZL_TYPE_INT8)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected address");
print_err_data(vm);
return -1;
}
if (addr.as.u == 0)
{
vm->dstack[vm->dtop++] =
(fzl_value_t){.type = FZL_TYPE_OBJECT, .as.obj = NULL};
break;
}
vm->dstack[vm->dtop++] = (fzl_value_t){
.type = FZL_TYPE_OBJECT, .as.obj = (fzl_vm_object_t *)addr.as.u};
break;
}
case FZL_OPCODE_CMP_EQ_STR:
{
if (vm->dtop < 2)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
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");
print_err_data(vm);
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");
print_err_data(vm);
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");
print_err_data(vm);
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");
print_err_data(vm);
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");
print_err_data(vm);
return -1;
}
fzl_vm_env_t *parent = vm->estack[vm->etop - 2];
fzl_vm_env_t *current = vm->estack[vm->etop - 1];
if (vm->etop < 2)
{
snprintf(last_err, sizeof(last_err),
"runtime error - cannot escape object from global env");
print_err_data(vm);
return -1;
}
escape_recursive(current, parent, obj.as.obj);
vm->dstack[vm->dtop++] = obj;
break;
}
case FZL_OPCODE_ALLOC_OBJECT:
{
uint64_t values_count = vm->ops[++vm->ip];
@@ -132,7 +421,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;
@@ -144,6 +443,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected value in data stack");
print_err_data(vm);
return -1;
}
@@ -155,6 +455,7 @@ int fzl_vm_run(fzl_vm_t *vm)
last_err, sizeof(last_err),
"runtime error - cannot access field #%lu of non-object type",
field_slot);
print_err_data(vm);
return -1;
}
@@ -163,6 +464,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - cannot access field #%lu", field_slot);
print_err_data(vm);
return -1;
}
@@ -176,6 +478,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -188,6 +491,7 @@ int fzl_vm_run(fzl_vm_t *vm)
last_err, sizeof(last_err),
"runtime error - cannot access field #%lu of non-object type",
field_slot);
print_err_data(vm);
return -1;
}
@@ -196,6 +500,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - cannot access field #%lu", field_slot);
print_err_data(vm);
return -1;
}
@@ -217,6 +522,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - no place to jump");
print_err_data(vm);
return -1;
}
@@ -229,6 +535,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -243,6 +550,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -257,6 +565,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -271,6 +580,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -285,6 +595,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -299,6 +610,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -313,6 +625,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected value in data stack");
print_err_data(vm);
return -1;
}
@@ -326,6 +639,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected value in data stack");
print_err_data(vm);
return -1;
}
@@ -344,6 +658,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -358,6 +673,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected two values in data stack");
print_err_data(vm);
return -1;
}
@@ -372,6 +688,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected var name in data stack");
print_err_data(vm);
return -1;
}
@@ -386,14 +703,28 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected 2 values in data stack");
print_err_data(vm);
return -1;
}
fzl_value_t writevar = vm->dstack[--vm->dtop];
fzl_value_t value = vm->dstack[--vm->dtop];
fzl_vm_env_wresult_t wresult = fzl_env_writevalue(
vm->estack[vm->etop - 1], (char *)writevar.as.s.value, value);
char *wrname = (char *)writevar.as.s.value;
bool wrfound;
fzl_value_t wrenv;
ssize_t wrlvl = -1;
for (ssize_t i = vm->etop - 1; i >= 0; i--)
{
if ((wrfound = fzl_env_lookup(vm->estack[i], wrname, &wrenv)))
{
wrlvl = i;
break;
}
}
fzl_vm_env_wresult_t wresult =
fzl_env_writevalue(vm->estack[wrlvl], (char *)wrname, value);
if (wresult != FZL_VM_ENV_WRESULT_OK)
{
switch (wresult)
@@ -401,21 +732,25 @@ int fzl_vm_run(fzl_vm_t *vm)
case FZL_VM_ENV_WRESULT_ERR:
snprintf(last_err, sizeof(last_err),
"runtime error - failed to write variable");
print_err_data(vm);
return -1;
case FZL_VM_ENV_WRESULT_ERR_EXISTS:
snprintf(last_err, sizeof(last_err),
"runtime error - redefenition of '%s'",
writevar.as.s.value);
print_err_data(vm);
return -1;
case FZL_VM_ENV_WRESULT_ERR_NOT_FOUND:
snprintf(last_err, sizeof(last_err),
"runtime error - cannot find name '%s'",
writevar.as.s.value);
print_err_data(vm);
return -1;
default:
print_err_data(vm);
return -1;
}
}
@@ -439,6 +774,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - LOOKUP_ENV: empty data stack");
print_err_data(vm);
return -1;
}
@@ -474,11 +810,19 @@ 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 if (fn_id == FZL_BUILTIN_EXIT)
{
fzl_value_t arg = vm->dstack[--vm->dtop];
exit(arg.as.i);
}
else
{
snprintf(last_err, sizeof(last_err),
"runtime error - undefined builtin %lu", fn_id);
print_err_data(vm);
return -1;
}
}
@@ -490,6 +834,7 @@ int fzl_vm_run(fzl_vm_t *vm)
if (vm->consts_count <= cn)
{
snprintf(last_err, sizeof(last_err), "runtime error - unknown const");
print_err_data(vm);
return -1;
}
fzl_const_t c = vm->consts[cn];
@@ -505,6 +850,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected 2 values in stack");
print_err_data(vm);
return -1;
}
fzl_value_t add1 = vm->dstack[--vm->dtop];
@@ -518,6 +864,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected 2 values in stack");
print_err_data(vm);
return -1;
}
fzl_value_t sub2 = vm->dstack[--vm->dtop];
@@ -531,6 +878,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected 2 values in stack");
print_err_data(vm);
return -1;
}
fzl_value_t mul1 = vm->dstack[--vm->dtop];
@@ -544,6 +892,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected 2 values in stack");
print_err_data(vm);
return -1;
}
fzl_value_t div1 = vm->dstack[--vm->dtop];
@@ -557,6 +906,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected 2 values in stack");
print_err_data(vm);
return -1;
}
fzl_value_t pow2 = vm->dstack[--vm->dtop];
@@ -577,6 +927,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected 2 values in stack");
print_err_data(vm);
return -1;
}
fzl_value_t mod1 = vm->dstack[--vm->dtop];
@@ -590,6 +941,7 @@ int fzl_vm_run(fzl_vm_t *vm)
{
snprintf(last_err, sizeof(last_err),
"runtime error - expected value in stack");
print_err_data(vm);
return -1;
}
fzl_value_t neg_n = vm->dstack[--vm->dtop];
@@ -616,6 +968,7 @@ int fzl_vm_run(fzl_vm_t *vm)
default:
snprintf(last_err, sizeof(last_err),
"runtime error - unknown opcode %u", opcode);
print_err_data(vm);
return -1;
}
@@ -638,12 +991,6 @@ void fzl_freevm(fzl_vm_t *vm)
free((void *)vm->consts[i].as.string.chars);
}
for (size_t i = 0; i < vm->objects_count; i++)
{
free(vm->objects[i]->values);
free(vm->objects[i]);
}
free(vm->consts);
free(vm->ops);
free(vm);
src/vm/fzl_vm_debug.c
+24
View File
@@ -20,6 +20,30 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
switch (vm->ops[i])
{
case FZL_OPCODE_DEREFERENCE:
printf("DEREFERENCE\n");
break;
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
+22
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,21 @@ 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;
if (env->owned_objects[i]->values)
free(env->owned_objects[i]->values);
free(env->owned_objects[i]);
}
free(env->owned_objects);
}
free(env);
}