ADD: var index.

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

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; i<dim; i++)
 		{
@@ -218,15 +225,23 @@ int cstatic_check(cstatic* self, node* ast, symtable* sym, char* msg, size_t siz
 		// check dimension
 		size_t dim = ast->children.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;

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; i<self->children.size; i++)
+	{
+		node_add_child(clone, node_new_clone(self->children.data[i]));
+	}
+
+	return clone;
+}
 
 void node_add_child(node* self, node* child)
 {

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

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;

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; i<self->entries.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++;

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

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++;
 }

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]

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]

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]