about summary refs log tree commit diff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/bootstrap/codegen.pry78
-rw-r--r--src/bootstrap/parser.pry52
2 files changed, 47 insertions, 83 deletions
diff --git a/src/bootstrap/codegen.pry b/src/bootstrap/codegen.pry
index 6d5b1c8..0bc11f3 100644
--- a/src/bootstrap/codegen.pry
+++ b/src/bootstrap/codegen.pry
@@ -21,18 +21,15 @@ let Environment = struct {
 };
 
 let environment_create_scope = (e: *Environment) => void {
-	printf("CREATE SCOPE!!!!!!!!!!!: %d\n", (*e).scope_stack_len);
 	let scope = cast(*Scope, arena_alloc((*e).arena, sizeof(Scope)));
 	(*scope).variables = hashmap_init(16, (*e).arena);
 	(*((*e).scope_stack + cast(**Scope, (*e).scope_stack_len))) = scope;
 	(*e).scope_stack_len = (*e).scope_stack_len + 1;
-	printf("AFTER SCOPE!!!!!!!!!!!: %d\n", (*e).scope_stack_len);
 
 	return;
 };
 
 let environment_drop_scope = (e: *Environment) => void {
-	printf("DROP SCOPE!!!!!!!!!!!\n");
 	(*e).scope_stack_len = (*e).scope_stack_len - 1;
 
 	return;
@@ -178,9 +175,7 @@ let codegen_get_llvm_type = (c: *codegen, node: *Node) => *LLVMTypeRef {
 	if (*node).type == NODE_TYPE_FUNCTION_TYPE {
 		let function_type = *cast(*NODE_TYPE_FUNCTION_TYPE_DATA, (*node).data);
 		let retur_type = codegen_get_llvm_type(c, function_type.retur_type);
-		if retur_type == cast(*LLVMTypeRef, null) {
-			return cast(*LLVMTypeRef, null);
-		};
+		assert(retur_type != cast(*LLVMTypeRef, null));
 		let paramtypes = cast(*LLVMTypeRef, arena_alloc((*c).arena, sizeof(LLVMTypeRef) * 20));
 		let paramtypes_len = 0;
 		let is_varargs = 0;
@@ -197,9 +192,7 @@ let codegen_get_llvm_type = (c: *codegen, node: *Node) => *LLVMTypeRef {
 				};
 			};
 			let typ = codegen_get_llvm_type(c, param);
-			if typ == cast(*LLVMTypeRef, null) {
-				return cast(*LLVMTypeRef, null);
-			};
+			assert(typ != cast(*LLVMTypeRef, null));
 			if (*param).type == NODE_TYPE_FUNCTION_TYPE {
 				*typ = LLVMPointerType(*typ, 0);
 			};
@@ -219,9 +212,7 @@ let codegen_get_llvm_type = (c: *codegen, node: *Node) => *LLVMTypeRef {
 	if (*node).type == NODE_TYPE_POINTER_TYPE {
 		let pointer_type = *cast(*NODE_TYPE_POINTER_TYPE_DATA, (*node).data);
 		let inner_type = codegen_get_llvm_type(c, pointer_type.type);
-		if inner_type == cast(*LLVMTypeRef, null) {
-			return cast(*LLVMTypeRef, null);
-		};
+		assert(inner_type != cast(*LLVMTypeRef, null));
 		let r = cast(*LLVMTypeRef, arena_alloc((*c).arena, sizeof(LLVMTypeRef)));
 		*r = LLVMPointerType(*inner_type, 0);
 		return r;
@@ -338,10 +329,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		/* TODO */
 		assert((*v_type).type != NODE_TYPE_FUNCTION_TYPE);
 		let param_type = codegen_get_llvm_type(c, v_type);
-		if param_type == cast(*LLVMTypeRef, null) {
-			printf("LEL4\n");
-			return cast(*Variable, null);
-		};
+		assert(param_type != cast(*LLVMTypeRef, null));
 		if (*v_type).type == NODE_TYPE_FUNCTION_TYPE {
 			(*param_type) = LLVMPointerType(*param_type, 0);
 		};
@@ -376,10 +364,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 				};
 			};
 			let llvm_param_type = codegen_get_llvm_type(c, param_type);
-			if llvm_param_type == cast(*LLVMTypeRef, null) {
-				printf("LEL3\n");
-				return cast(*Variable, null);
-			};
+			assert(llvm_param_type != cast(*LLVMTypeRef, null));
 			if (*param_type).type == NODE_TYPE_FUNCTION_TYPE {
                         	(*llvm_param_type) = LLVMPointerType(*llvm_param_type, 0);
 			};
@@ -390,10 +375,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		};
 
 		let retur_type = codegen_get_llvm_type(c, function_definition.retur_type);
-		if retur_type == cast(*LLVMTypeRef, null) {
-			printf("LEL2\n");
-			return cast(*Variable, null);
-		};
+		assert(retur_type != cast(*LLVMTypeRef, null));
 
 		let function_type = LLVMFunctionType(*retur_type, llvm_param_types, i, 0);
 		let function = LLVMAddFunction((*c).llvm_module, name, function_type);
@@ -445,10 +427,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 			v.stack_level = cast(*i64, null);
 			v.node = param_node;
 			v.node_type = param_type;
-let xx =codegen_create_variable(c, v);
-		printf("THERE %s\n", param.name);
-			environment_add_variable((*c).environment, param.name, xx);
-		printf("HERE\n");
+			environment_add_variable((*c).environment, param.name, codegen_create_variable(c, v));
 			parameters_index = parameters_index + 1;
 		};
 
@@ -481,13 +460,9 @@ let xx =codegen_create_variable(c, v);
 	if ((*expression).type == NODE_EQUALITY_EXPRESSION) {
 		let exp = (*(cast(*NODE_EQUALITY_EXPRESSION_DATA, (*expression).data)));
 		let lhs_value = codegen_generate_expression_value(c, exp.lhs, cast(*i8, null));
-		if lhs_value == cast(*Variable, null) {
-			return cast(*Variable, null);
-		};
+		assert(lhs_value != cast(*Variable, null));
 		let rhs_value = codegen_generate_expression_value(c, exp.rhs, cast(*i8, null));
-		if rhs_value == cast(*Variable, null) {
-			return cast(*Variable, null);
-		};
+		assert(rhs_value != cast(*Variable, null));
 
 		/* TODO: compare types */
 		let op = -1;
@@ -530,13 +505,9 @@ let xx =codegen_create_variable(c, v);
 	if ((*expression).type == NODE_ADDITIVE_EXPRESSION) {
 		let exp = (*(cast(*NODE_ADDITIVE_EXPRESSION_DATA, (*expression).data)));
 		let lhs_value = codegen_generate_expression_value(c, exp.lhs, cast(*i8, null));
-		if lhs_value == cast(*Variable, null) {
-			return cast(*Variable, null);
-		};
+		assert(lhs_value != cast(*Variable, null));
 		let rhs_value = codegen_generate_expression_value(c, exp.rhs, cast(*i8, null));
-		if rhs_value == cast(*Variable, null) {
-			return cast(*Variable, null);
-		};
+		assert(rhs_value != cast(*Variable, null));
 
 		/* TODO: Compare types */
 
@@ -577,9 +548,7 @@ let xx =codegen_create_variable(c, v);
 	if ((*expression).type == NODE_UNARY_EXPRESSION) {
 		let exp = (*(cast(*NODE_UNARY_EXPRESSION_DATA, (*expression).data)));
 		let k = codegen_generate_expression_value(c, exp.expression, cast(*i8, null));
-		if k == cast(*Variable, null) {
-			return cast(*Variable, null);
-		};
+		assert(k != cast(*Variable, null));
 
 		let r = cast(LLVMValueRef, null);
 		let typ = (*k).node_type;
@@ -614,9 +583,7 @@ let xx =codegen_create_variable(c, v);
 			let n = (*k).node_type;
 			typ = (*cast(*NODE_TYPE_POINTER_TYPE_DATA, (*n).data)).type;
 			let ptr_type = codegen_get_llvm_type(c, typ);
-			if ptr_type == cast(*LLVMTypeRef, null) {
-				return cast(*Variable, null);
-			};
+			assert(ptr_type != cast(*LLVMTypeRef, null));
                         r = LLVMBuildLoad2((*c).builder, *ptr_type, (*k).value, "");
 		};
 
@@ -632,10 +599,7 @@ let xx =codegen_create_variable(c, v);
 		/* TODO: Check if already exists */
 
 		let function_type = codegen_get_llvm_type(c, expression);
-		if function_type == cast(*LLVMTypeRef, null) {
-			printf("LOL\n");
-			return cast(*Variable, null);
-		};
+		assert(function_type != cast(*LLVMTypeRef, null));
 		let function = LLVMAddFunction((*c).llvm_module, name, *function_type);
 		let v = Variable{};
 		v.value = function;
@@ -750,9 +714,7 @@ let codegen_generate_return_statement = (c: *codegen, stmt: *NODE_RETURN_STATEME
 	};
 
 	let val = codegen_generate_expression_value(c, expression, cast(*i8, null));
-	if val == cast(*Variable, null) {
-		return 1;
-	};
+	assert(val != cast(*Variable, null));
 
 	/* TODO: Check type */
 
@@ -808,10 +770,7 @@ let codegen_generate_function_call_statement = (c: *codegen, statement: *Node) =
 	while i < (*stmt).arguments_len {
 		let argument = (*((*stmt).arguments + cast(**Node, i))); /* TODO */
 		let arg = codegen_generate_expression_value(c, argument, cast(*i8, null));
-		if arg == cast(*Variable, null) {
-			printf("BAD\n");
-			assert(false);
-		};
+		assert(arg != cast(*Variable, null));
 		/* TODO: Typecheck */
 
 		(*(arguments + cast(*LLVMValueRef, i))) = (*arg).value;
@@ -820,10 +779,7 @@ let codegen_generate_function_call_statement = (c: *codegen, statement: *Node) =
 	};
 
 	let function_type = codegen_get_llvm_type(c, (*function).node_type);
-	if function_type == cast(*LLVMTypeRef, null) {
-		printf("FN Type\n");
-		assert(false);
-	};
+	assert(function_type != cast(*LLVMTypeRef, null));
 
 	let res = LLVMBuildCall2((*c).builder, *function_type, (*function).value, arguments, i, "");
 
diff --git a/src/bootstrap/parser.pry b/src/bootstrap/parser.pry
index 444a033..bc36a41 100644
--- a/src/bootstrap/parser.pry
+++ b/src/bootstrap/parser.pry
@@ -611,7 +611,6 @@ let parser_parse_function_definition = (p: *parser) => *Node {
 		return cast(*Node, null);
 	};
 	
-	/* TODO: Body */
 	let statements = cast(**Node, arena_alloc((*p).arena, sizeof(*Node) * 100));
 	let i = 0;
 	while true {
@@ -670,7 +669,7 @@ let parser_parse_primary_expression = (p: *parser) => *Node {
 	if (*tok).type == TOKEN_IDENTIFIER {
 	    let d = cast(*NODE_PRIMARY_EXPRESSION_IDENTIFIER_DATA, arena_alloc((*p).arena, sizeof(NODE_PRIMARY_EXPRESSION_IDENTIFIER_DATA)));
 	    (*d).name = cast(*i8, (*tok).data);
-	    (*d).type = cast(*Node, null); /* TODO */
+	    (*d).type = cast(*Node, null);
 	    let n = Node{};
 	    n.type = NODE_PRIMARY_EXPRESSION_IDENTIFIER;
 	    n.data = cast(*void, d);
@@ -854,7 +853,11 @@ let parser_parse_unary_expression = (p: *parser) => *Node {
 
 	let new_lhs_data = cast(*NODE_UNARY_EXPRESSION_DATA, arena_alloc((*p).arena, sizeof(NODE_UNARY_EXPRESSION_DATA)));
 	((*new_lhs_data).typ) = typ;
-	((*new_lhs_data).expression) = parser_parse_unary_expression(p); /* TODO: try? */
+	let e = parser_parse_unary_expression(p);
+	if e == cast(*Node, null) {
+		return cast(*Node, null);
+	};
+	((*new_lhs_data).expression) = e;
 	let new_lhs = Node{};
 	new_lhs.type = NODE_UNARY_EXPRESSION;
 	new_lhs.data = cast(*void, new_lhs_data);
@@ -864,6 +867,9 @@ let parser_parse_unary_expression = (p: *parser) => *Node {
 /* MultiplicativeExpression ::= UnaryExpression (("*" | "/" | "%") UnaryExpression)* */
 let parser_parse_multiplicative_expression = (p: *parser) => *Node {
 	let lhs = parser_parse_unary_expression(p);
+	if lhs == cast(*Node, null) {
+		return cast(*Node, null);
+	};
 
 	while true {
 		let typ = -1;
@@ -881,6 +887,9 @@ let parser_parse_multiplicative_expression = (p: *parser) => *Node {
 		};
 
 		let rhs = parser_parse_unary_expression(p);
+		if rhs == cast(*Node, null) {
+			return cast(*Node, null);
+		};
 
 		let new_lhs_data = cast(*NODE_MULTIPLICATIVE_EXPRESSION_DATA, arena_alloc((*p).arena, sizeof(NODE_MULTIPLICATIVE_EXPRESSION_DATA)));
 		((*new_lhs_data).lhs) = lhs;
@@ -897,6 +906,9 @@ let parser_parse_multiplicative_expression = (p: *parser) => *Node {
 /* AdditiveExpression ::= MultiplicativeExpression (("+" | "-") MultiplicativeExpression)* */
 let parser_parse_additive_expression = (p: *parser) => *Node {
 	let lhs = parser_parse_multiplicative_expression(p);
+	if lhs == cast(*Node, null) {
+		return cast(*Node, null);
+	};
 
 	while true {
 		let plus = parser_accept_token(p, TOKEN_PLUS);
@@ -909,6 +921,9 @@ let parser_parse_additive_expression = (p: *parser) => *Node {
 		};
 
 		let rhs = parser_parse_multiplicative_expression(p);
+		if rhs == cast(*Node, null) {
+			return cast(*Node, null);
+		};
 
 		let new_lhs_data = cast(*NODE_ADDITIVE_EXPRESSION_DATA, arena_alloc((*p).arena, sizeof(NODE_ADDITIVE_EXPRESSION_DATA)));
 		((*new_lhs_data).addition) = plus != cast(*token, null);
@@ -940,13 +955,15 @@ let parser_parse_expression = (p: *parser) => *Node {
 let parse_assignment_statement = (p: *parser) => *Node {
 	let is_declaration = false;
 	if parser_accept_token(p, TOKEN_LET) != cast(*token, null) {
-	    printf("IS DECLARATION\n");
 	    is_declaration = true;
 	};
+	
+	let is_dereference = false;
+	if parser_accept_token(p, TOKEN_MUL) != cast(*token, null) {
+	    is_dereference = true;
+	};
 
-	/* TODO: is_dereference */
-
-	let lhs = parser_parse_expression(p); /* TODO */
+	let lhs = parser_parse_expression(p);
 	if lhs == cast(*Node, null) {
 	    return cast(*Node, null);
 	};	
@@ -955,14 +972,14 @@ let parse_assignment_statement = (p: *parser) => *Node {
 	    return cast(*Node, null);
 	};
 	
-	let rhs = parser_parse_expression(p); /* TODO */
+	let rhs = parser_parse_expression(p);
 	if rhs == cast(*Node, null) {
 	    return cast(*Node, null);
 	};
 
 	let d = cast(*NODE_ASSIGNMENT_STATEMENT_DATA , arena_alloc((*p).arena, sizeof(NODE_ASSIGNMENT_STATEMENT_DATA)));
 	(*d).is_declaration = is_declaration;
-	(*d).is_dereference = false;
+	(*d).is_dereference = is_dereference;
 	(*d).lhs = lhs;
 	(*d).rhs = rhs;
 	let n = Node{};
@@ -1011,10 +1028,10 @@ let parser_parse_import_declaration = (p: *parser) => *Node {
 	let bytes_read = read(file, file_contents, file_size);
 	(*(file_contents + cast(*i8, bytes_read))) = '\0';
 
-	let todo = slice{};
-	todo.data = cast(*void, file_contents);
-	todo.data_len = file_size;
-	let inner_tokenizer = tokenizer_init((*p).arena, todo);
+	let f = slice{};
+	f.data = cast(*void, file_contents);
+	f.data_len = file_size;
+	let inner_tokenizer = tokenizer_init((*p).arena, f);
 	let tokens = tokenizer_tokenize(inner_tokenizer);
 
 	let buf2 = cast(*i8, arena_alloc((*p).arena, 90));
@@ -1197,12 +1214,3 @@ let parse_program = (p: *parser) => *Node {
 let parse = (p: *parser) => *Node {
 	return parse_program(p);
 };
-
-/*
-
-For example -2:
-
-* parsing assignment statement
-* parsing ident and num literals
-
-*/
generated by cgit-pink (baitinq) at 2025-11-10 21:03:54 +0000