From 067dfdc6383857b8518625271635c1f2e9d3ce3e Mon Sep 17 00:00:00 2001 From: bog Date: Fri, 25 Aug 2023 18:22:44 +0200 Subject: [PATCH] ADD: var index. --- src/compiler.c | 3 ++- src/cstatic.c | 23 +++++++++++++++++++---- src/node.c | 13 +++++++++++++ src/node.h | 2 ++ src/parser.y | 2 +- src/symtable.c | 11 ++++++++--- src/symtable.h | 4 +++- src/vm.c | 4 ++-- tests/err_vars.wuz | 1 + tests/test_array.wuz | 3 ++- tests/test_vars.wuz | 10 ++++++++++ 11 files changed, 63 insertions(+), 13 deletions(-) diff --git a/src/compiler.c b/src/compiler.c index 4b763db..7d2adeb 100644 --- a/src/compiler.c +++ b/src/compiler.c @@ -42,7 +42,8 @@ void compile_node(compiler* self, node* root, program* prog) size_t id = symtable_declare( self->sym, root->children.data[0]->value, - ty + ty, + root->children.data[1] ); compile_node(self, root->children.data[1], prog); diff --git a/src/cstatic.c b/src/cstatic.c index 01c35c5..dd0d3c6 100644 --- a/src/cstatic.c +++ b/src/cstatic.c @@ -119,6 +119,13 @@ type* cstatic_resolve_new(cstatic* self, symtable* sym, node* ast) // find inner type using first array element size_t dim = ast->children.data[1]->children.size; node* iter = ast->children.data[0]; + + if (iter->type == NODE_IDENT) + { + symentry* entry = symtable_find(sym, + iter->value); + iter = entry->sym_node; + } for (size_t i=0; ichildren.data[1]->children.size; size_t real_dim = 0; - + node* iter = ast->children.data[0]; + + if (iter->type == NODE_IDENT) + { + symentry* entry = symtable_find(sym, + iter->value); + iter = entry->sym_node; + } + while (iter->type == NODE_ARRAY) { iter = iter->children.data[0]; real_dim++; } - - if (real_dim != dim) + + if (real_dim < dim) { snprintf(msg, size, "E: array dimension mismatch:" @@ -308,7 +323,7 @@ int cstatic_check(cstatic* self, node* ast, symtable* sym, char* msg, size_t siz type* ty = cstatic_resolve_new(self, sym, ast->children.data[1]); assert(ty); - symtable_declare(sym, name, ty); + symtable_declare(sym, name, ty, ast->children.data[1]); type_free(ty); free(ty); return 1; diff --git a/src/node.c b/src/node.c index e259de3..1159d2a 100644 --- a/src/node.c +++ b/src/node.c @@ -36,6 +36,19 @@ void node_free(node* self) self->children.capacity = 0; } +node* node_new_clone(node* self) +{ + assert(self); + node* clone = malloc(sizeof(node)); + node_init(clone, self->type, self->value, self->lineno); + + for (size_t i=0; ichildren.size; i++) + { + node_add_child(clone, node_new_clone(self->children.data[i])); + } + + return clone; +} void node_add_child(node* self, node* child) { diff --git a/src/node.h b/src/node.h index 5313322..1d2aaa4 100644 --- a/src/node.h +++ b/src/node.h @@ -38,6 +38,8 @@ typedef struct node { void node_init(node* self, int type, char const* value, int lineno); void node_free(node* self); +node* node_new_clone(node* self); + void node_add_child(node* self, node* child); size_t node_str(node* self, char* buffer, size_t size); diff --git a/src/parser.y b/src/parser.y index 8b39a66..1774d1c 100644 --- a/src/parser.y +++ b/src/parser.y @@ -79,7 +79,7 @@ exprs: expr: // INDEX - array array { + expr array { node *n = malloc(sizeof(node)); node_init(n, NODE_INDEX, "", line); size_t const SZ = $1 + $2; diff --git a/src/symtable.c b/src/symtable.c index 5657a76..972c4d9 100644 --- a/src/symtable.c +++ b/src/symtable.c @@ -4,7 +4,7 @@ void symtable_init(symtable* self) { assert(self); self->id = 0; - + self->entries.size = 0; self->entries.capacity = 1; self->entries.data = malloc(sizeof(symentry*) @@ -14,9 +14,13 @@ void symtable_init(symtable* self) void symtable_free(symtable* self) { assert(self); - + for (size_t i=0; ientries.size; i++) { + node_free(self->entries.data[i]->sym_node); + free(self->entries.data[i]->sym_node); + self->entries.data[i]->sym_node = NULL; + free(self->entries.data[i]->name); type_free(self->entries.data[i]->ty); free(self->entries.data[i]->ty); @@ -30,7 +34,7 @@ void symtable_free(symtable* self) self->entries.data = NULL; } -size_t symtable_declare(symtable* self, char const* name, type* ty) +size_t symtable_declare(symtable* self, char const* name, type* ty, node* sym_node) { assert(self); @@ -52,6 +56,7 @@ size_t symtable_declare(symtable* self, char const* name, type* ty) self->entries.data[self->entries.size]->name = str_new(name); self->entries.data[self->entries.size]->ty = type_new_clone(ty); self->entries.data[self->entries.size]->id = self->id; + self->entries.data[self->entries.size]->sym_node = node_new_clone(sym_node); self->entries.size++; return self->id++; diff --git a/src/symtable.h b/src/symtable.h index bcf93b3..6a49206 100644 --- a/src/symtable.h +++ b/src/symtable.h @@ -3,11 +3,13 @@ #include "commons.h" #include "type.h" +#include "node.h" typedef struct { size_t id; char* name; type* ty; + node* sym_node; } symentry; typedef struct { @@ -23,7 +25,7 @@ typedef struct { void symtable_init(symtable* self); void symtable_free(symtable* self); -size_t symtable_declare(symtable* self, char const* name, type* ty); +size_t symtable_declare(symtable* self, char const* name, type* ty, node* sym_node); symentry* symtable_find(symtable* self, char const* name); #endif diff --git a/src/vm.c b/src/vm.c index 05aea5c..2899292 100644 --- a/src/vm.c +++ b/src/vm.c @@ -677,12 +677,12 @@ void vm_aderef(vm* self) arr = val; } } - assert(val); + assert(val); + vm_push_value(self, val); value_free(idx); free(idx); - value_free(arr); free(arr); self->pc++; } diff --git a/tests/err_vars.wuz b/tests/err_vars.wuz index 646c10e..57415d5 100644 --- a/tests/err_vars.wuz +++ b/tests/err_vars.wuz @@ -1,3 +1,4 @@ let x = 0 x + 1.2 let x = false x + "false" let x=0 let x=7 +let x=[1, 2] x[7, 9] diff --git a/tests/test_array.wuz b/tests/test_array.wuz index 4d4ef43..c3b4d5b 100644 --- a/tests/test_array.wuz +++ b/tests/test_array.wuz @@ -25,4 +25,5 @@ assert [0, 1, 0, 1, 0, 1] == 3 * [0, 1] assert [0, 0, 0, 0, 0, 0, 1] == 2 * (3 * [0]) + [1] - +assert [2, 4] == [[2, 4], [7, 9]][0] +assert [7, 9] == [[2, 4], [7, 9]][1] diff --git a/tests/test_vars.wuz b/tests/test_vars.wuz index 9bfceb2..cb73a8d 100644 --- a/tests/test_vars.wuz +++ b/tests/test_vars.wuz @@ -3,3 +3,13 @@ let b = 7 let c = a * b + 1 assert 29 == c + +let d = [[2, 4], [6, 8]] +assert 6 == d[1, 0] +assert [2, 4] == d[0] +assert [6, 8] == d[1] + +let e = 0 +let f = 1 +assert [2, 4] == d[e] +assert [6, 8] == d[f]