Basic expression parsing

Author: MightyHelper

.idea/workspace.xml

@@ -77,7 +77,7 @@ public void parse() {
 			matchToken_program();
 			match(eofToken); // Assert EOF
 		} catch (StackOverflowError e) {
-			throw new CompilerError(lexer.peek().location(), "Stack overflow error. You probably gave me code that is too large :c.");
+			throw new CompilerError(lexer.peek().location(), "Stack overflow error. You probably gave me code that is too large :c.", e);
 		}
 	}
 }

src/main/java/ko/carbonel/compiler/ParserAssistant.java

@@ -30,6 +30,10 @@ public CompilerError(String message) {
 		super(message);
 	}
 
+	public CompilerError(FileLocation location, String s, Throwable cause) {
+		super(buildMessage(location, s), cause);
+	}
+
 	private static String buildMessage(FileLocation start, String message) {
 		if (start == null || start.isInternal()) return message;
 		String out = generateLocation(start, message)

src/main/java/ko/carbonel/compiler/exception/CompilerError.java

@@ -9,6 +9,8 @@
 import ko.carbonel.json.SerializeClass;
 
 import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.Predicate;
 
 import static ko.carbonel.json.SerializeClass.AST;
 import static ko.carbonel.json.SerializeClass.TS;
@@ -64,6 +66,7 @@ public void addClass() {
 
 	@CalledByParser
 	public void addMethod() {
+		endBlock();
 		Logger.output("Adding method " + activeMethod.name.lexeme() + " to class " + activeClass.name.lexeme());
 		activeMethod.setParentScope(activeClass);
 		activeMethod.block = (BlockStatementEntry) statementStack.pop();
@@ -273,12 +276,34 @@ public void newBlock() {
 
 	@CalledByParser
 	public void endBlock() {
-		List<StatementEntry> statementList = new ArrayList<>();
-		while (!(statementStack.peek() instanceof BlockStatementEntry block)) {
-			statementList.add(statementStack.pop());
-		}
-		block.setStatements(statementList);
-		Logger.output("Block: " + block);
+		popStatementUntil(BlockStatementEntry.class, (block, statements) -> {
+			block.setStatements(statements);
+			Logger.output("Block: " + block);
+		});
+	}
+
+	private <T extends StatementEntry> void popStatementUntil(Class<T> clazz, BiConsumer<T, List<StatementEntry>> callback) {
+		popUntil(clazz, callback, statementStack, it->false);
+	}
+
+	/**
+	 * Pop until the top of the stack is an instance of clazz, then call callback with the top of the stack cast to clazz and the popped statements
+	 *
+	 * @param <T>       The class to pop until
+	 * @param <S>       The type of the stack
+	 * @param clazz     The class to pop until
+	 * @param callback  The callback to call
+	 * @param stack     The stack to pop from
+	 * @param predicate A predicate to test the popped statements - if true, the popped statements are added to the list anyway
+	 */
+	private <T extends S, S> void popUntil(Class<T> clazz, BiConsumer<T, List<S>> callback, Stack<S> stack, Predicate<T> predicate) {
+		List<S> statementList = new ArrayList<>();
+		while (!(clazz.isInstance(stack.peek())) || predicate.test(clazz.cast(stack.peek()))) statementList.add(0, stack.pop());
+		callback.accept(clazz.cast(stack.peek()), statementList);
+	}
+
+	private <T extends ExpressionEntry> void popExpressionUntil(Class<T> clazz, BiConsumer<T, List<ExpressionEntry>> callback, Predicate<T> predicate) {
+		popUntil(clazz, callback, expressionStack, predicate);
 	}
 
 	@CalledByParser
@@ -303,4 +328,24 @@ public void endMain() {
 		Logger.output("Main end");
 		activeMethod.block = (BlockStatementEntry) statementStack.pop();
 	}
+
+	@CalledByParser
+	public void expMethodCall() {
+		LiteralExpressionEntry id = (LiteralExpressionEntry) expressionStack.pop();
+		MethodCallExpressionEntry exp = new MethodCallExpressionEntry();
+		exp.setMethodName(id.literal);
+		expressionStack.push(exp);
+		Logger.output("Method call: " + exp);
+	}
+
+	@CalledByParser
+	public void endMethodCall(){
+		popExpressionUntil(MethodCallExpressionEntry.class, (methodCall, expressions) -> {
+			methodCall.setArguments(expressions);
+			ExpressionEntry pop = expressionStack.pop();
+			if (pop != methodCall) throw new RuntimeException("Method call not on top of stack");
+			expressionStack.push(methodCall);
+			Logger.output("Method call: " + methodCall);
+		}, it->it.arguments!=null);
+	}
 }

src/main/java/ko/carbonel/compiler/generated/AttrTinyRustParser.java

@@ -9,8 +9,8 @@
 
 public class BinaryExpressionEntry extends ExpressionEntry {
 	@SerializeClass(AST) public ExpressionEntry left;
-	@SerializeClass(AST) public ExpressionEntry right;
 	@SerializeClass(AST) public TinyRustLexerToken operator;
+	@SerializeClass(AST) public ExpressionEntry right;
 	public ExpressionEntry getLeft() {
 		return left;
 	}

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/TinyRustSymbolTable.java

@@ -19,6 +19,6 @@ public void setStatements(List<StatementEntry> statements) {
 
 	@Override
 	public String toString() {
-		return "BlockStatementEntry<" + statements.size() + " statements>";
+		return "BlockStatementEntry<" + (statements == null ? 0 : statements.size()) + " statements>";
 	}
 }

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/ast/BinaryExpressionEntry.java

@@ -0,0 +1,32 @@
+package ko.carbonel.compiler.intermediate.tinyRust.ast;
+
+import ko.carbonel.compiler.stream.lexer.tinyRust.model.TinyRustLexerToken;
+import ko.carbonel.json.SerializeClass;
+
+import java.util.List;
+
+public class MethodCallExpressionEntry extends ExpressionEntry {
+	@SerializeClass("ast") public TinyRustLexerToken methodName;
+	@SerializeClass("ast") public List<ExpressionEntry> arguments;
+
+	public TinyRustLexerToken methodName() {
+		return methodName;
+	}
+
+	public void setMethodName(TinyRustLexerToken methodName) {
+		this.methodName = methodName;
+	}
+
+	public List<ExpressionEntry> arguments() {
+		return arguments;
+	}
+
+	public void setArguments(List<ExpressionEntry> arguments) {
+		this.arguments = arguments;
+	}
+
+	@Override
+	public String toString() {
+		return "MethodCall<%s %s>".formatted(methodName, arguments);
+	}
+}

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/ast/BlockStatementEntry.java

@@ -5,7 +5,7 @@ AssignF ::= SimpleChain_star {st.assignLHS()} "=" ExpOr {st.assignRHS()} | {st.a
 Assign ::= "SELF" {st.expLit(v_0)} AssignF | SimpleVar {st.assignLHS()} "=" ExpOr {st.assignRHS()}
 Attr ::= Type ":" Vars ";" {st.activeClass.addVariables(false, v_0, v_2)} | "PUBLIC" Type ":" Vars ";" {st.activeClass.addVariables(true, v_1, v_3)}
 BraceExp ::= "(" ExpOr ")" StaticMethodCallF
-ChainFF ::= Args StaticMethodCallF | VarF
+ChainFF ::= {st.expMethodCall()} Args {st.endMethodCall()} StaticMethodCallF | VarF
 Chain ::= "." "ATTR_ID" {st.expChainWith(v_1)} ChainFF
 ClassFFF ::= ":" Type { st.activeClass.setSuperClass(v_1) } "{" ClassFF | "{" ClassFF
 ClassFF ::= Member_star "}" | "}"
@@ -38,7 +38,7 @@ LocalVars_star ::= Type ":" Vars ";" { st.activeMethod.addVariables(v_0, v_2) }
 Member_starF ::= Member_star | "λ"
 Member_star ::= Member Member_starF
 Member ::= "CREATE" {st.setConstructorActive(v_0)} Params "{" {st.newBlock()} programFFFF {st.addMethod()} | Attr | Method
-MethodCall ::= "ATTR_ID" Args StaticMethodCallF
+MethodCall ::= "ATTR_ID" {st.expLit(v_0)} {st.expMethodCall()} Args {st.endMethodCall()} StaticMethodCallF
 MethodF ::= Stmt_star {st.endBlock()} "}" | {st.endBlock()} "}"
 Method ::= "STATIC" "FN" "ATTR_ID" { st.newMethod(true, v_2) } Params "-" ">" ReturnType {st.activeMethod.setReturn(v_7)} "{" {st.newBlock()} programFFFF { st.addMethod() } | "FN" "ATTR_ID" { st.newMethod(false, v_1) } Params "-" ">" ReturnType { st.activeMethod.setReturn(v_6)} "{" {st.newBlock()} programFFFF { st.addMethod() }
 NewCallFF ::= "CLASS_ID" Args StaticMethodCallF | PrimType "[" ExpOr "]"

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/ast/MethodCallExpressionEntry.java

@@ -0,0 +1,57 @@
+{
+	"classEntries": [
+		{
+			"name": {"lexeme": "I32"},
+			"methods": []
+		},
+		{
+			"name": {"lexeme": "Bool"},
+			"methods": []
+		},
+		{
+			"name": {"lexeme": "Char"},
+			"methods": []
+		},
+		{
+			"name": {"lexeme": "Str"},
+			"methods": []
+		},
+		{
+			"name": {"lexeme": "Object"},
+			"methods": []
+		},
+		{
+			"name": {"lexeme": "IO"},
+			"methods": []
+		}
+	],
+	"main": {
+		"block": {"statements": [
+			{"expression": {
+				"left": {
+					"left": {
+						"left": {"literal": {"lexeme": "a"}},
+						"right": {
+							"operator": {"lexeme": "!"},
+							"expression": {"literal": {"lexeme": "b"}}
+						},
+						"operator": {"lexeme": "*"}
+					},
+					"right": {"literal": {"lexeme": "c"}},
+					"operator": {"lexeme": "+"}
+				},
+				"right": {"literal": {"lexeme": "d"}},
+				"operator": {"lexeme": "+"}
+			}},
+			{
+				"lhs": {"literal": {"lexeme": "b"}},
+				"rhs": {"literal": {"lexeme": "2"}}
+			},
+			{
+				"lhs": {"literal": {"lexeme": "a"}},
+				"rhs": {"literal": {"lexeme": "1"}}
+			}
+		]},
+		"name": {"lexeme": "main"}
+	}
+}