From 403ab706559ff91c954e4fdf218f19ff027b0520 Mon Sep 17 00:00:00 2001 From: Bruder John Date: Thu, 30 May 2024 19:07:29 +0200 Subject: [PATCH] Adapted Binary Expression --- .idea/misc.xml | 2 +- src/main/java/Main.java | 38 +++++++++---------- src/main/java/ast/VarNode.java | 30 --------------- .../ast/expression/BinaryExpressionNode.java | 4 +- .../ast/expression/ExpresssionOperator.java | 14 +++++++ .../ast/expression/UnaryExpressionNode.java | 2 + .../statement/AssignmentStatementNode.java | 9 ++--- src/main/java/parser/ASTBuilder.java | 12 +++--- src/main/java/semantic/SemanticAnalyzer.java | 18 ++++----- src/main/java/semantic/SemanticVisitor.java | 3 -- src/main/resources/CompilerInput.java | 12 +++++- src/test/java/semantic/SemanticTest.java | 15 ++++++-- 12 files changed, 76 insertions(+), 83 deletions(-) delete mode 100644 src/main/java/ast/VarNode.java create mode 100644 src/main/java/ast/expression/ExpresssionOperator.java diff --git a/.idea/misc.xml b/.idea/misc.xml index f26d89f..bb14756 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -40,7 +40,7 @@ - + \ No newline at end of file diff --git a/src/main/java/Main.java b/src/main/java/Main.java index d5aa802..94d29cf 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -38,37 +38,37 @@ public class Main { CommonTokenStream tokenStream = new CommonTokenStream(lexer); // Printing the tokens - tokenStream.fill(); - List tokens = tokenStream.getTokens(); - System.out.println("-------------------- Scanner -> tokens --------------------"); - for (Token token : tokens) { - String tokenType = SimpleJavaLexer.VOCABULARY.getSymbolicName(token.getType()); - String tokenText = token.getText(); - // System.out.println("Token Type: " + tokenType + ", Token Text: " + - // tokenText); - System.out.println(tokenType + " " + tokenText); - } - System.out.println(); +// tokenStream.fill(); +// List tokens = tokenStream.getTokens(); +// System.out.println("-------------------- Scanner -> tokens --------------------"); +// for (Token token : tokens) { +// String tokenType = SimpleJavaLexer.VOCABULARY.getSymbolicName(token.getType()); +// String tokenText = token.getText(); +// // System.out.println("Token Type: " + tokenType + ", Token Text: " + +// // tokenText); +// System.out.println(tokenType + " " + tokenText); +// } +// System.out.println(); /* ------------------------- Parser -> Parsetree ------------------------- */ SimpleJavaParser parser = new SimpleJavaParser(tokenStream); ParseTree parseTree = parser.program(); // parse the input // Printing the parse tree - System.out.println("-------------------- Parser -> Parsetree --------------------"); - System.out.println(parseTree.toStringTree(parser)); - printTree(parseTree, parser, 0); - System.out.println(); +// System.out.println("-------------------- Parser -> Parsetree --------------------"); +// System.out.println(parseTree.toStringTree(parser)); +// printTree(parseTree, parser, 0); +// System.out.println(); /* ------------------------- AST builder -> AST ------------------------- */ ASTBuilder astBuilder = new ASTBuilder(); ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree); // Printing the AST - System.out.println("-------------------- AST builder -> AST --------------------"); - // System.out.println("AST: " + ast.toString()); - printAST(abstractSyntaxTree, 0); - System.out.println(); +// System.out.println("-------------------- AST builder -> AST --------------------"); +// // System.out.println("AST: " + ast.toString()); +// printAST(abstractSyntaxTree, 0); +// System.out.println(); /* * ------------------------- Semantic Analyzer -> Tast ------------------------- diff --git a/src/main/java/ast/VarNode.java b/src/main/java/ast/VarNode.java deleted file mode 100644 index 519f552..0000000 --- a/src/main/java/ast/VarNode.java +++ /dev/null @@ -1,30 +0,0 @@ -package ast; - -import ast.type.TypeNode; -import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; -import visitor.Visitable; - -public class VarNode implements ASTNode, Visitable { - - private String identifier; - private TypeNode type; - - public VarNode(TypeNode type, String identifier){ - this.type = type; - this.identifier = identifier; - } - - public TypeNode getType(){ - return type; - } - - public String getIdentifier(){ - return identifier; - } - - @Override - public TypeCheckResult accept(SemanticVisitor visitor) { - return visitor.analyze(this); - } -} diff --git a/src/main/java/ast/expression/BinaryExpressionNode.java b/src/main/java/ast/expression/BinaryExpressionNode.java index c912408..e4a0e41 100644 --- a/src/main/java/ast/expression/BinaryExpressionNode.java +++ b/src/main/java/ast/expression/BinaryExpressionNode.java @@ -7,9 +7,9 @@ import visitor.Visitable; public class BinaryExpressionNode implements ExpressionNode, Visitable { public ExpressionNode left; public ExpressionNode right; - public String operator; // Stores the operator as a string (e.g., "+", "-", "&&") + public ExpresssionOperator operator; // Stores the operator as a string (e.g., "+", "-", "&&") - public BinaryExpressionNode(ExpressionNode left, ExpressionNode right, String operator) { + public BinaryExpressionNode(ExpressionNode left, ExpressionNode right, ExpresssionOperator operator) { this.left = left; this.right = right; this.operator = operator; diff --git a/src/main/java/ast/expression/ExpresssionOperator.java b/src/main/java/ast/expression/ExpresssionOperator.java new file mode 100644 index 0000000..b1f62a3 --- /dev/null +++ b/src/main/java/ast/expression/ExpresssionOperator.java @@ -0,0 +1,14 @@ +package ast.expression; + +public enum ExpresssionOperator { + DOT, // . + PLUS, // + + MINUS, // - + MULTIPLY, // * + DIVIDE, // / + NOT, // ! + ASSIGNMENT, // = + EQUALS, // == + UNEQUALS, // != + ERROR //TODO: Remove This +} diff --git a/src/main/java/ast/expression/UnaryExpressionNode.java b/src/main/java/ast/expression/UnaryExpressionNode.java index 24d1832..be1a660 100644 --- a/src/main/java/ast/expression/UnaryExpressionNode.java +++ b/src/main/java/ast/expression/UnaryExpressionNode.java @@ -18,3 +18,5 @@ public class UnaryExpressionNode implements ExpressionNode, Visitable { return visitor.analyze(this); } } + + diff --git a/src/main/java/ast/statement/AssignmentStatementNode.java b/src/main/java/ast/statement/AssignmentStatementNode.java index 9f6a395..f9fd38e 100644 --- a/src/main/java/ast/statement/AssignmentStatementNode.java +++ b/src/main/java/ast/statement/AssignmentStatementNode.java @@ -1,17 +1,14 @@ package ast.statement; -import ast.VarNode; -import ast.expression.ExpressionNode; +import ast.expression.BinaryExpressionNode; import semantic.SemanticVisitor; import typechecker.TypeCheckResult; import visitor.Visitable; public class AssignmentStatementNode extends StatementNode implements Visitable { - public VarNode varNode; - public ExpressionNode expression; + public BinaryExpressionNode expression; - public AssignmentStatementNode(VarNode varNode, ExpressionNode expression) { - this.varNode = varNode; + public AssignmentStatementNode(BinaryExpressionNode expression) { this.expression = expression; } diff --git a/src/main/java/parser/ASTBuilder.java b/src/main/java/parser/ASTBuilder.java index e32be97..0f3b09c 100644 --- a/src/main/java/parser/ASTBuilder.java +++ b/src/main/java/parser/ASTBuilder.java @@ -3,6 +3,7 @@ package parser; import ast.*; import ast.expression.BinaryExpressionNode; import ast.expression.ExpressionNode; +import ast.expression.ExpresssionOperator; import ast.expression.IdentifierExpressionNode; import ast.expression.UnaryExpressionNode; import ast.member.FieldNode; @@ -137,14 +138,14 @@ public class ASTBuilder extends SimpleJavaBaseVisitor { @Override public ASTNode visitAssignmentStatement(SimpleJavaParser.AssignmentStatementContext ctx) { - VarNode varNode = (VarNode) visit(ctx.var()); - ExpressionNode expression = (ExpressionNode) visit(ctx.expression()); - return new AssignmentStatementNode(varNode, expression); + + BinaryExpressionNode expression = (BinaryExpressionNode) visit(ctx.expression()); + return new AssignmentStatementNode(expression); } @Override public ASTNode visitVar(SimpleJavaParser.VarContext ctx) { - return new VarNode(new BaseTypeNode(EnumTypeNode.INT), ctx.getText()); + return null; } @Override @@ -180,8 +181,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor { if (ctx.getChildCount() == 3 && ctx.getChild(1) instanceof TerminalNode) { ExpressionNode left = (ExpressionNode) visit(ctx.expression(0)); ExpressionNode right = (ExpressionNode) visit(ctx.expression(1)); - String operator = ctx.getChild(1).getText(); - return new BinaryExpressionNode(left, right, operator); + return new BinaryExpressionNode(left, right, ExpresssionOperator.ERROR); } // Handle unary operations else if (ctx.getChildCount() == 2) { diff --git a/src/main/java/semantic/SemanticAnalyzer.java b/src/main/java/semantic/SemanticAnalyzer.java index 362af42..9ccfe98 100644 --- a/src/main/java/semantic/SemanticAnalyzer.java +++ b/src/main/java/semantic/SemanticAnalyzer.java @@ -145,21 +145,17 @@ public class SemanticAnalyzer implements SemanticVisitor { @Override public TypeCheckResult analyze(AssignmentStatementNode assignmentStatementNode) { - if (assignmentStatementNode.expression instanceof LiteralNode literalNode) { - TypeCheckResult varResult = assignmentStatementNode.varNode.accept(this); - TypeCheckResult expressionResult = assignmentStatementNode.expression.accept(this); - } - return new TypeCheckResult(true, null); - } - - @Override - public TypeCheckResult analyze(VarNode toCheck) { - return new TypeCheckResult(true, null); + boolean valid = true; + BinaryExpressionNode binaryExpressionNode = assignmentStatementNode.expression; + var result = binaryExpressionNode.accept(this); + valid = valid && result.isValid(); + return new TypeCheckResult(valid, null); } @Override public TypeCheckResult analyze(BinaryExpressionNode toCheck) { - return null; + boolean valid = true; + return new TypeCheckResult(valid, null); } @Override diff --git a/src/main/java/semantic/SemanticVisitor.java b/src/main/java/semantic/SemanticVisitor.java index 99d0cb8..66db83e 100644 --- a/src/main/java/semantic/SemanticVisitor.java +++ b/src/main/java/semantic/SemanticVisitor.java @@ -3,7 +3,6 @@ package semantic; import ast.ClassNode; import ast.ProgramNode; -import ast.VarNode; import ast.expression.BinaryExpressionNode; import ast.expression.IdentifierExpressionNode; import ast.expression.UnaryExpressionNode; @@ -24,8 +23,6 @@ public interface SemanticVisitor { TypeCheckResult analyze(AssignmentStatementNode toCheck); - TypeCheckResult analyze(VarNode toCheck); - TypeCheckResult analyze(BinaryExpressionNode toCheck); TypeCheckResult analyze(IdentifierExpressionNode toCheck); diff --git a/src/main/resources/CompilerInput.java b/src/main/resources/CompilerInput.java index 2efd50e..1cbe5ca 100644 --- a/src/main/resources/CompilerInput.java +++ b/src/main/resources/CompilerInput.java @@ -2,9 +2,17 @@ public class Example { public int a; - public static int testMethod(char x, int a){ - + public static int testMethod(char x){ } +} + +public class Test { + + public static int testMethod(char x, int a){ + + + + } } \ No newline at end of file diff --git a/src/test/java/semantic/SemanticTest.java b/src/test/java/semantic/SemanticTest.java index d35a93f..83287ca 100644 --- a/src/test/java/semantic/SemanticTest.java +++ b/src/test/java/semantic/SemanticTest.java @@ -2,7 +2,10 @@ package semantic; import ast.*; +import ast.expression.BinaryExpressionNode; import ast.expression.ExpressionNode; +import ast.expression.ExpresssionOperator; +import ast.expression.IdentifierExpressionNode; import ast.member.FieldNode; import ast.member.MemberNode; import ast.member.MethodNode; @@ -76,10 +79,16 @@ public class SemanticTest { List statementNodeList = new ArrayList(); - VarNode varNode = new VarNode(new BaseTypeNode(EnumTypeNode.INT), "localVar1"); - ExpressionNode expressionNode = new LiteralNode(1); + ExpressionNode expressionNodeObjectVariableLeft = new IdentifierExpressionNode("this"); + ExpressionNode expressionNodeObjectVariableRight = new IdentifierExpressionNode("objectVar"); - StatementNode statementNode1 = new AssignmentStatementNode(varNode, expressionNode); + ExpressionNode expressionNodeLeft = new BinaryExpressionNode(expressionNodeObjectVariableLeft, expressionNodeObjectVariableRight, ExpresssionOperator.DOT); + + ExpressionNode expressionNodeRight = new LiteralNode(1); + + BinaryExpressionNode expressionNode = new BinaryExpressionNode(expressionNodeLeft, expressionNodeRight, ExpresssionOperator.ASSIGNMENT); + + StatementNode statementNode1 = new AssignmentStatementNode(expressionNode); statementNodeList.add(statementNode1); MemberNode memberNode3 = new MethodNode(accessTypeNode, new BaseTypeNode(EnumTypeNode.INT), "testVar2",parameterListNode, statementNodeList );