fixed compound node

examples/for.l

@@ -1,21 +1,15 @@
-import std::io;
+import std;
 
 i32 main()
 {
-	[u32] list = [1, 2, 3, 4, 5];
+	u32 x = 4;
-
+	loop x == 3 {
-	// iterative loop
+		u32 b = 3;
-	loop (0.., list) |i, v| {
-		printf("%d\n", i);
 	}
 
-	// conditional loop
+	loop (0.., test) |k, i| {
-	loop a == 3 {
 
 	}
+	u32 b = 3;
 
-	// infinite loop
-	loop {
-
-	}
 }

examples/generics.l

@@ -1,4 +0,0 @@
-u32 sum<T>(T x, T y)
-{
-	return x + y;
-}

examples/hello_world.l

@@ -1,6 +1,8 @@
-import test;
+import std;
 
 i32 main()
 {
-	print_msg("Hello world!");
+	print("Hello world!\n");
+
+	return 0;
 }

examples/test.l

@@ -1,10 +0,0 @@
-import std::io;
-
-module log {
-
-void print_msg([u8] msg)
-{
-	printf("%s\n", msg);
-}
-
-}

lc.c

@@ -127,6 +127,7 @@ void print_ast(ast_node *node, int depth) {
 			for (usize i = 0; i < node->expr.compound.stmt_len; ++i) {
 				print_ast(node->expr.compound.statements[i], depth + 1);
 			}
+			break;
 		case NODE_CALL:
 			printf("Call: %.*s\n", (int)node->expr.call.name_len, node->expr.call.name);
 			current = node->expr.call.parameters;
@@ -219,7 +220,7 @@ void print_ast(ast_node *node, int depth) {
 
 int main(void)
 {
-	FILE *fp = fopen("test.l", "r");
+	FILE *fp = fopen("examples/for.l", "r");
 	usize size = 0;
 	fseek(fp, 0, SEEK_END);
 	size = ftell(fp);

parser.c

@@ -448,76 +448,81 @@ ast_node *parse_expression(parser *p)
 		return node;
 	}
 
-	if (match(p, TOKEN_LCURLY)) {
+	if (match(p, TOKEN_DOT)) {
-		ast_node *node = arena_alloc(p->allocator, sizeof(ast_node));
+		if (match(p, TOKEN_LCURLY)) {
-		node->type = NODE_STRUCT_INIT;
+			ast_node *node = arena_alloc(p->allocator, sizeof(ast_node));
+			node->type = NODE_STRUCT_INIT;
 
-		if (match(p, TOKEN_RCURLY))
+			if (match(p, TOKEN_RCURLY))
-		{
-			node->expr.struct_init.members = NULL;
-			return node;
-		}
-
-		snapshot arena_start = arena_snapshot(p->allocator);
-		node->expr.struct_init.members = arena_alloc(p->allocator, sizeof(ast_node));
-		node->expr.struct_init.members->type = NODE_UNIT;
-		node->expr.struct_init.members->expr.unit_node.expr = parse_expression(p);
-		ast_node *tail = node->expr.struct_init.members;
-		node->expr.struct_init.members_len = 1;
-
-		/* In this case, there is only one parameter */
-		if (match(p, TOKEN_RCURLY))
-		{
-			return node;
-		}
-
-		if (match(p, TOKEN_COMMA))
-		{
-			ast_node *expr = parse_expression(p);
-			if (expr)
 			{
-				while (!match(p, TOKEN_RCURLY))
+				node->expr.struct_init.members = NULL;
+				return node;
+			}
+
+			snapshot arena_start = arena_snapshot(p->allocator);
+			node->expr.struct_init.members = arena_alloc(p->allocator, sizeof(ast_node));
+			node->expr.struct_init.members->type = NODE_UNIT;
+			node->expr.struct_init.members->expr.unit_node.expr = parse_expression(p);
+			ast_node *tail = node->expr.struct_init.members;
+			node->expr.struct_init.members_len = 1;
+
+			/* In this case, there is only one parameter */
+			if (match(p, TOKEN_RCURLY))
+			{
+				return node;
+			}
+
+			if (match(p, TOKEN_COMMA))
+			{
+				ast_node *expr = parse_expression(p);
+				if (expr)
 				{
-					if (!match(p, TOKEN_COMMA))
+					while (!match(p, TOKEN_RCURLY))
 					{
-						error(p, "expected `}`.");
+						if (!match(p, TOKEN_COMMA))
-						arena_reset_to_snapshot(p->allocator, arena_start);
+						{
-						return NULL;
+							error(p, "expected `}`.");
+							arena_reset_to_snapshot(p->allocator, arena_start);
+							return NULL;
+						}
+						tail->expr.unit_node.next = arena_alloc(p->allocator, sizeof(ast_node));
+						tail->expr.unit_node.next->expr.unit_node.expr = expr;
+						tail = tail->expr.unit_node.next;
+						tail->type = NODE_UNIT;
+						expr = parse_expression(p);
+						if (!expr)
+						{
+							error(p, "expected `}`.");
+							arena_reset_to_snapshot(p->allocator, arena_start);
+							return NULL;
+						}
+						node->expr.struct_init.members_len += 1;
 					}
+
 					tail->expr.unit_node.next = arena_alloc(p->allocator, sizeof(ast_node));
 					tail->expr.unit_node.next->expr.unit_node.expr = expr;
 					tail = tail->expr.unit_node.next;
 					tail->type = NODE_UNIT;
-					expr = parse_expression(p);
-					if (!expr)
-					{
-						error(p, "expected `}`.");
-						arena_reset_to_snapshot(p->allocator, arena_start);
-						return NULL;
-					}
-					node->expr.struct_init.members_len += 1;
 				}
-
+				else
-				tail->expr.unit_node.next = arena_alloc(p->allocator, sizeof(ast_node));
+				{
-				tail->expr.unit_node.next->expr.unit_node.expr = expr;
+					error(p, "expected member initialization.");
-				tail = tail->expr.unit_node.next;
+					arena_reset_to_snapshot(p->allocator, arena_start);
-				tail->type = NODE_UNIT;
+					return NULL;
+				}
 			}
 			else
 			{
-				error(p, "expected member initialization.");
+				error(p, "expected `}`.");
 				arena_reset_to_snapshot(p->allocator, arena_start);
 				return NULL;
 			}
-		}
+
-		else
+			return node;
-		{
+		} else {
-			error(p, "expected `}`.");
+			error(p, "unexpected `.`");
-			arena_reset_to_snapshot(p->allocator, arena_start);
 			return NULL;
 		}
-
-		return node;
 	}
 
 	if (p->tokens && ((p->tokens->type >= TOKEN_DOUBLE_EQ && p->tokens->type <= TOKEN_NOT_EQ) || (p->tokens->type >= TOKEN_LSHIFT_EQ && p->tokens->type <= TOKEN_DOUBLE_AND)))
@@ -580,31 +585,56 @@ ast_node *parse_expression(parser *p)
 
 static ast_node *parse_compound(parser *p)
 {
-	if (!match(p, TOKEN_LCURLY))
+	if (!match(p, TOKEN_LCURLY)) {
-	{
+		error(p, "expected `{`.");
-		error(p, "expected `{` for beginning of a block.");
 		return NULL;
 	}
-	ast_node *compound = arena_alloc(p->allocator, sizeof(ast_node));
+
-	compound->type = NODE_UNIT;
+	ast_node *node = arena_alloc(p->allocator, sizeof(ast_node));
-	compound->expr.unit_node.expr = NULL;
+	node->type = NODE_UNIT;
-    compound->expr.unit_node.next = NULL;
+
-	ast_node* tail = compound;
+	if (match(p, TOKEN_RCURLY))
-	// FIXME: This only works with correct blocks, incorrect blocks segfault
-	while (p->tokens->type != TOKEN_RCURLY &&
-           p->tokens->type != TOKEN_END)
 	{
-		ast_node* stmt = parse_statement(p);
+		node->expr.unit_node.expr = NULL;
+		node->expr.unit_node.next = NULL;
+		return node;
+	}
+
+	snapshot arena_start = arena_snapshot(p->allocator);
+	node->expr.unit_node.expr = parse_statement(p);
+	ast_node *tail = node;
+
+	/* In this case, there is only one parameter */
+	if (match(p, TOKEN_RCURLY))
+	{
+		return node;
+	}
+
+	ast_node *expr = parse_statement(p);
+	if (expr)
+	{
+		while (!match(p, TOKEN_RCURLY))
+		{
+			tail->expr.unit_node.next = arena_alloc(p->allocator, sizeof(ast_node));
+			tail->expr.unit_node.next->expr.unit_node.expr = expr;
+			tail = tail->expr.unit_node.next;
+			tail->type = NODE_UNIT;
+			expr = parse_statement(p);
+			if (!expr)
+			{
+				error(p, "expected `}`.");
+				arena_reset_to_snapshot(p->allocator, arena_start);
+				return NULL;
+			}
+		}
+
 		tail->expr.unit_node.next = arena_alloc(p->allocator, sizeof(ast_node));
-		tail->expr.unit_node.next->expr.unit_node.expr = stmt;
+		tail->expr.unit_node.next->expr.unit_node.expr = expr;
 		tail = tail->expr.unit_node.next;
 		tail->type = NODE_UNIT;
 	}
-	if (p->tokens->type != TOKEN_RCURLY) {
+
-		error(p, "Unterminated block.");
+	return node;
-		return NULL;
-	}
-	return compound;
 }
 
 static ast_node *parse_for(parser *p)
@@ -650,12 +680,12 @@ static ast_node *parse_for(parser *p)
 					arena_reset_to_snapshot(p->allocator, arena_start);
 					return NULL;
 				}
-				node->expr.fr.slice_len += 1;
 			}
 
 			tail->expr.unit_node.next = arena_alloc(p->allocator, sizeof(ast_node));
 			tail->expr.unit_node.next->expr.unit_node.expr = expr;
 			tail = tail->expr.unit_node.next;
+			node->expr.fr.slice_len += 1;
 			tail->type = NODE_UNIT;
 		}
 		else
@@ -715,13 +745,13 @@ parse_captures:
 					arena_reset_to_snapshot(p->allocator, arena_start);
 					return NULL;
 				}
-				node->expr.fr.capture_len += 1;
 			}
 
 			tail->expr.unit_node.next = arena_alloc(p->allocator, sizeof(ast_node));
 			tail->expr.unit_node.next->expr.unit_node.expr = expr;
 			tail = tail->expr.unit_node.next;
 			tail->type = NODE_UNIT;
+			node->expr.fr.capture_len += 1;
 		} else {
 			error(p, "expected identifier.");
 			arena_reset_to_snapshot(p->allocator, arena_start);
@@ -734,6 +764,7 @@ parse_captures:
 	}
 
 parse_body:;
+	printf("%d %d\n", node->expr.fr.capture_len, node->expr.fr.slice_len);
 	if (node->expr.fr.capture_len != node->expr.fr.slice_len) {
 		error(p, "invalid number of captures.");
 		return NULL;
@@ -747,6 +778,7 @@ parse_body:;
 static ast_node *parse_while(parser *p)
 {
 	ast_node *condition = parse_expression(p);
+	//printf("%d %d\n", p->tokens->type, TOKEN_RCURLY);
 	ast_node *body = parse_compound(p);
 	ast_node *node = arena_alloc(p->allocator, sizeof(ast_node));
 	node->type = NODE_WHILE;

test.l

@@ -1,5 +1,5 @@
 u32 a()
 {
-	Person v = {x = 3, y = 4, z = 5};
+	[u32] v = {1, 2, 3};
 	return z[0];
 }