ADD: array index.

src/array.c

@@ -30,6 +30,12 @@ void array_free(array* self)
 	free(self->type); self->type = NULL;
 }
 
+struct value* array_deref_copy(array* self, size_t index)
+{
+	assert(index < self->children.size);
+	return (struct value*) value_new_clone((value*)self->children.data[index]);
+}
+
 void array_push(array* self, struct value* element)
 {
 	assert(self);

src/array.h

@@ -18,6 +18,7 @@ typedef struct {
 void array_init(array* self, type* elements_type);
 void array_free(array* self);
 
+struct value* array_deref_copy(array* self, size_t index);
 void array_push(array* self, struct value* element);
 
 size_t array_str(array* self, char* buffer, size_t size);

src/compiler.c

@@ -17,7 +17,12 @@ void compile_node(compiler* self, node* root, program* prog)
 	assert(root);
 	assert(prog);
 	
-	if (root->type == NODE_MUL)
+	if (root->type == NODE_INDEX)
+	{
+		compile_children(self, root, prog);
+		program_add_instr(prog, OP_ADEREF, NO_PARAM);
+	}
+	else if (root->type == NODE_MUL)
 	{
 		cstatic cs;
 		cstatic_init(&cs);

src/cstatic.c

@@ -46,7 +46,20 @@ type* cstatic_resolve_new(cstatic* self, node* ast)
 		}
 	}
 
-	if (ast->type == NODE_INTEGER)
+	if (ast->type == NODE_INDEX)
+	{
+		// find inner type using first array element
+		size_t dim = ast->children.data[1]->children.size;
+		node* iter = ast->children.data[0];
+
+		for (size_t i=0; i<dim; i++)
+		{
+			iter = iter->children.data[0];
+		}
+		
+		return cstatic_resolve_new(self, iter);
+	}
+	else if (ast->type == NODE_INTEGER)
 	{
 		return cstatic_new_type(self, TY_INTEGER);
 	}
@@ -126,8 +139,52 @@ int cstatic_check(cstatic* self, node* ast, char* msg, size_t size)
 		}
 
 	}
+
 	// Arrays
-	if (ast->type == NODE_ARRAY)
+	if (ast->type == NODE_INDEX)
+	{
+		// check dimension
+		size_t dim = ast->children.data[1]->children.size;
+		size_t real_dim = 0;
+
+		node* iter = ast->children.data[0];
+		while (iter->type == NODE_ARRAY)
+		{
+			iter = iter->children.data[0];
+			real_dim++;
+		}
+		
+		if (real_dim != dim)
+		{
+			snprintf(msg, size, 
+				"E: array dimension mismatch:"
+				" expected '%ld', got '%ld'.",
+				real_dim, dim);
+
+			return 0;
+		}
+
+		// check that all indexes are integers
+		for (size_t i=0; i<dim; i++)
+		{
+			int status = cstatic_check_type_base(
+				self, 
+				ast->children.data[1]->children.data[i],
+				msg,
+				size,
+				TY_INTEGER,
+				TYPE_END
+			);
+
+			if (!status)
+			{
+				return 0;
+			}
+		}
+		
+		return 1;
+	}
+	else if (ast->type == NODE_ARRAY)
 	{
 		assert(ast->children.size > 0);
 		type* ty = cstatic_resolve_new(self, ast->children.data[0]);
@@ -151,6 +208,9 @@ int cstatic_check(cstatic* self, node* ast, char* msg, size_t size)
 			}
 		}
 
+		type_free(ty);
+		free(ty);
+
 		return 1;
 	}
 
@@ -388,7 +448,7 @@ int cstatic_check_type_base(cstatic* self, node* lhs,
 
 	size_t sz = snprintf(msg, size, "E(%d): type mismatch, got '%s', ",
 				lhs->lineno,
-				TypesStr[left]);
+				TypesStr[left] + strlen("TY_"));
 
 	sz += snprintf(msg + sz, size - sz, "expected: \n");
 	
@@ -397,7 +457,7 @@ int cstatic_check_type_base(cstatic* self, node* lhs,
 	while (all_types[j] != TYPE_END)
 	{
 		sz += snprintf(msg + sz, size - sz, "\t '%s'\n",
-				TypesStr[all_types[j]]);
+				TypesStr[all_types[j]] + strlen("TY_"));
 		j++;
 	}
 
@@ -411,17 +471,27 @@ int cstatic_check_same_type(cstatic* self, node* lhs, node* rhs,
 	assert(lhs);
 	assert(rhs);
 	
-	int left = cstatic_resolve_base_type(self, lhs);
+	type* left = cstatic_resolve_new(self, lhs);
-	int right = cstatic_resolve_base_type(self, rhs);
+	type* right = cstatic_resolve_new(self, rhs);
 
-	if (left != right)
+	if (!type_equals(left, right))
 	{
-		snprintf(msg, size, "E(%d): expected '%s', got '%s'.",
+		size_t sz = 0;
-				lhs->lineno,
+
-				TypesStr[left],
+		sz += snprintf(msg + sz, size - sz, "E(%d): expected '", lhs->lineno);
-				TypesStr[right]);
+		sz += type_str(left, msg + sz, size - sz);
+		sz += snprintf(msg + sz, size - sz, "', got '");
+		sz += type_str(right, msg + sz, size - sz);
+		sz += snprintf(msg + sz, size - sz, "'");
+
+		type_free(left); free(left);
+		type_free(right); free(right);
+
 		return 0;
 	}
 
+	type_free(left); free(left);
+	type_free(right); free(right);
+
 	return 1;
 }

src/lex.l

@@ -20,6 +20,7 @@ STRING \"[^"]*\"
 {WHITESPACES} {}
 
 "assert" { return ASSERT; }
+"," { return COMMA; }
 "+" { return ADD; }
 "-" { return SUB; }
 "*" { return MUL; }

src/main.c

@@ -60,13 +60,15 @@ int main(int argc, char** argv)
 	{
 		size_t const BUF = 1024;
 		char buffer[BUF];
-		
+		memset(buffer, 0, BUF);	
 		node_str(ast, buffer, BUF);
 		printf("-- ast ---\n%s\n\n", buffer);
 	
+		memset(buffer, 0, BUF);	
 		program_str(&prog, buffer, BUF);
 		printf("--- program ---\n%s\n", buffer);
 
+		memset(buffer, 0, BUF);	
 		vm_str(&v, buffer, BUF);
 		printf("--- stack ---\n%s\n", buffer);
 	}

src/node.h

@@ -10,7 +10,7 @@
 	G(NODE_ASSERT), \
 	G(NODE_UADD), G(NODE_USUB), G(NODE_ADD), G(NODE_SUB), \
 	G(NODE_MUL), G(NODE_DIV), G(NODE_MOD), G(NODE_POW), \
-	G(NODE_ARRAY)
+	G(NODE_ARRAY), G(NODE_INDEX)
 
 
 #include "mutils.h"

src/opcodes.h

@@ -28,7 +28,8 @@
 	G(OP_FUSUB), \
 	G(OP_CAT), \
 	G(OP_SMUL), \
-	G(OP_MKARRAY)
+	G(OP_MKARRAY), \
+	G(OP_ADEREF)
 
 enum Opcodes {
 	OPCODES(GEN_ENUM)

src/parser.y

@@ -23,7 +23,8 @@
 
 %left ASSERT
 %token <str> BOOLEAN INTEGER FLOAT STRING
-%type <n_children> expr exprs prog;
+%type <n_children> expr exprs prog array arrays builtins
+%type <n_children> expr_list 
 %left EQ NE
 %left AND
 %left OR
@@ -31,7 +32,7 @@
 %left MUL DIV MOD
 %left POW
 %left NOT
-%token OPAR CPAR OSQUARE CSQUARE
+%token OPAR CPAR OSQUARE CSQUARE COMMA
 
 %%
 
@@ -66,7 +67,36 @@ exprs:
 
 
 expr:
-    	ASSERT expr {
+    	// INDEX
+    	array array {
+		node *n = malloc(sizeof(node));
+		node_init(n, NODE_INDEX, "", line);
+		size_t const SZ = $1 + $2;
+		node* all[SZ];
+		for (size_t i=0; i<SZ; i++)
+		{
+			all[i] = stack_pop();
+		}
+	
+		for (size_t i=0; i<SZ; i++)
+		{
+			node_add_child(n, all[SZ - 1 - i]);
+		}
+
+		stack_push(n);
+		$$ = 1;
+	}
+
+	// EXPRESSIONS
+    	| array {
+		$$ = 1;
+	}
+	
+	| builtins {
+		$$ = $1;
+	}
+
+    	| ASSERT expr {
 		node *n = malloc(sizeof(node));
 		node_init(n, NODE_ASSERT, "", line);
 		node_add_child(n, stack_pop());
@@ -213,27 +243,12 @@ expr:
 		$$ = $2;
 	}
 
-	| OSQUARE exprs CSQUARE {
-		node *n = malloc(sizeof(node));
-		node_init(n, NODE_ARRAY, "", line);
 	
-		node* elements[$2];
+;
 
-		for (size_t i=0; i<$2; i++)
+builtins:
-		{
-			elements[i] = stack_pop();
-		}
 
-		for (size_t i=0; i<$2; i++)
+	STRING { 
-		{
-			node_add_child(n, elements[$2 - 1 - i]);
-		}
-		
-		stack_push(n);
-		$$ = 1;
-	}
-
-	| STRING { 
 		node* n = malloc(sizeof(node));
 		size_t const SZ = strlen($1);
 		char str[SZ - 2];
@@ -267,6 +282,34 @@ expr:
 	}
 ;
 
+expr_list:
+	 expr { $$ = $1; }
+	 | expr_list COMMA expr { $$ = $1 + $3; }
+;
+
+array: 
+	OSQUARE expr_list CSQUARE {
+		node *n = malloc(sizeof(node));
+		node_init(n, NODE_ARRAY, "", line);
+		
+		node* elements[$2];
+
+		for (size_t i=0; i<$2; i++)
+		{
+			elements[i] = stack_pop();
+		}
+		
+		for (size_t i=0; i<$2; i++)
+		{
+			node_add_child(n, elements[$2 - 1 - i]);
+		}
+		
+		stack_push(n);
+		$$ = 1;
+	}
+
+;
+
 %%
 
 void yyerror(char const* msg)

src/vm.c

@@ -70,6 +70,7 @@ void vm_exec(vm* self, program* prog)
 			case OP_CAT: vm_cat(self); break;
 
 			case OP_MKARRAY: vm_mkarray(self, param); break;
+			case OP_ADEREF: vm_aderef(self); break;
 
 			default: {
 				fprintf(stderr, "unknown opcode %s\n",
@@ -568,8 +569,8 @@ void vm_mkarray(vm* self, int param)
 		array_push(arr, (struct value*) elements[i]);
 	}
 	
-
 	value_init_array(arr_val, arr, elements[0]->lineno);
+
 	vm_push_value(self, arr_val);
 
 	for (int i=0; i<param; i++)
@@ -583,3 +584,39 @@ void vm_mkarray(vm* self, int param)
 
 	self->pc++;
 }
+
+void vm_aderef(vm* self)
+{
+	assert(self);
+	
+	value* idx = vm_pop_value(self);
+	value* arr = vm_pop_value(self);
+
+	array* idx_array = idx->val.array_val;
+	
+	value* val = NULL;
+
+	for (size_t i=0; i<idx_array->children.size; i++)
+	{
+		size_t index = ((value*) idx_array->children.data[i])->val.integer;
+
+		val = (value*) array_deref_copy(
+				arr->val.array_val, 
+				index);
+
+		if (val->type->base_type == TY_ARRAY)
+		{
+			value_free(arr);
+			free(arr);
+			arr = val;
+		}
+	}
+	assert(val);
+
+	vm_push_value(self, val);
+
+	value_free(idx); free(idx);
+	value_free(arr); free(arr);
+
+	self->pc++;
+}

src/vm.h

@@ -54,4 +54,6 @@ void vm_smul(vm* self);
 void vm_cat(vm* self);
 void vm_mkarray(vm* self, int param);
 
+void vm_aderef(vm* self);
+
 #endif

tests/err_ty_array.wuz

@@ -1,3 +1,8 @@
 []
-[1 2 3 "4"]
+[1, 2, 3, "4"]
-[ [0 1] ["0" "1"] ]
+[ [0, 1], ["0", "1"] ]
+[1, 2, 3]["a"]
+[1, 2, 3][false]
+[1, 2, 3][3.14]
+[1, 2, 3][ [0, 1] ]
+[1, 2, 3][0, 0]

tests/test_array.wuz

@@ -1,11 +1,23 @@
-assert [1 - 2 3] == [-1 3]
+assert [1, 2, 3] == [1, 2, 3]
-assert [1 -2 3] == [1 -2 3]
+assert ["a", "b", "c"] == ["a", "b", "c"]
+
+assert [1, 2, 3] != [7, 2, 3]
+assert [1, 2, 3] != [1, 2, 3, 4]
+
+assert ["a", "b", "c"] != ["ac", "b", "c"]
+assert ["a", "b", "c"] != ["a", "b", "c", "d"]
+
+assert 3 == [3, 8, 9][0]
+assert 8 == [3, 8, 9][1]
+assert 9 == [3, 8, 9][2]
+
+assert "8" == ["3", "8", "9"][2 - 1]
+
+assert 7 == [[4, 6], [9, 2, 7], [3, 3, 2]][1, 2]
+assert 9 == [[4, 6], [9, 2, 7], [3, 3, 2]][[2, 9, 1][2], 0]
+
+
+
 
-assert [1 2 3] == [1 2 3]
-assert ["a" "b" "c"] == ["a" "b" "c"]
 
-assert [1 2 3] != [7 2 3]
-assert [1 2 3] != [1 2 3 4]
 
-assert ["a" "b" "c"] != ["ac" "b" "c"]
-assert ["a" "b" "c"] != ["a" "b" "c" "d"]