From 4775c3f47e21bd5e4faf469ab6f2a5dc52511ddd Mon Sep 17 00:00:00 2001 From: entep01 Date: Thu, 4 Jul 2024 16:30:19 +0200 Subject: [PATCH] Fixes and changed For Builder --- README.md | 104 +++++++++++++ src/main/java/ast/ASTNode.java | 14 -- src/main/java/ast/ClassNode.java | 9 +- src/main/java/ast/ProgramNode.java | 2 +- .../binaryexpressions/BinaryNode.java | 4 +- .../binaryexpressions/CalculationNode.java | 12 +- .../binaryexpressions/DotNode.java | 24 ++- ...ctionNode.java => DotSubtractionNode.java} | 89 ++++++----- .../binaryexpressions/NonCalculationNode.java | 30 ++-- .../unaryexpressions/MemberAccessNode.java | 14 +- .../expressions/unaryexpressions/NotNode.java | 18 ++- .../unaryexpressions/UnaryNode.java | 6 +- .../java/ast/literal/BooleanLiteralNode.java | 11 -- .../java/ast/literal/CharLiteralNode.java | 11 -- src/main/java/ast/literal/LiteralNode.java | 31 ---- .../java/ast/members/ConstructorNode.java | 3 +- src/main/java/ast/members/FieldNode.java | 5 +- src/main/java/ast/members/MemberNode.java | 5 +- src/main/java/ast/members/MethodNode.java | 10 +- .../java/ast/parameters/ParameterNode.java | 2 +- .../ast/statementexpressions/AssignNode.java | 2 +- .../statementexpressions/AssignableNode.java | 8 +- .../IStatementExpressionNode.java | 3 +- .../NewDeclarationNode.java | 2 +- .../crementexpressions/DecrementNode.java | 4 +- .../crementexpressions/IncrementNode.java | 3 +- .../ChainedMethodNode.java | 2 +- .../MethodCallNode.java | 2 +- .../TargetNode.java | 3 +- src/main/java/ast/statements/BlockNode.java | 6 +- .../ast/statements/BlockStatementNode.java | 10 -- src/main/java/ast/statements/ElseNode.java | 2 +- src/main/java/ast/statements/IfElseNode.java | 2 +- src/main/java/ast/statements/IfNode.java | 2 +- .../LocalVariableDeclarationNode.java | 2 +- src/main/java/ast/statements/ReturnNode.java | 4 +- src/main/java/ast/statements/WhileNode.java | 3 +- .../java/ast/type/AccessModifierNode.java | 2 +- src/main/java/ast/type/ValueNode.java | 2 +- src/main/java/ast/type/type/BaseType.java | 6 +- src/main/java/ast/type/type/ITypeNode.java | 1 - .../java/ast/type/type/ReferenceType.java | 11 +- src/main/java/ast/type/type/TypeEnum.java | 3 +- src/main/java/bytecode/ByteCodeGenerator.java | 6 +- src/main/java/bytecode/ClassCodeGen.java | 10 +- src/main/java/bytecode/MethodCodeGen.java | 39 +++-- .../java/bytecode/visitor/MethodVisitor.java | 18 ++- .../java/bytecode/visitor/ProgramVisitor.java | 2 +- .../java/parser/astBuilder/ASTBuilder.java | 22 +-- src/main/java/semantic/Scope.java | 2 +- src/main/java/semantic/SemanticAnalyzer.java | 12 +- src/main/java/semantic/SemanticVisitor.java | 3 +- .../TypeCheckResult.java | 44 +++--- .../java/semantic/context/ClassContext.java | 4 +- src/main/java/semantic/context/Context.java | 2 +- .../java/semantic/context/FieldContext.java | 4 +- src/main/java/visitor/Visitable.java | 2 +- src/test/java/parser/AstBuilderTest.java | 12 +- src/test/java/parser/Helper.java | 4 +- src/test/java/parser/ParserTest.java | 138 ------------------ src/test/java/parser/ScannerTest.java | 45 ------ src/test/java/semantic/BeginnToTAST.java | 45 ------ src/test/java/semantic/SemanticHelper.java | 2 +- src/test/java/semantic/SemanticTest.java | 5 - .../CallMethodFromObjekt$Car.class | Bin 448 -> 0 bytes .../CallMethodFromObjekt.class | Bin 461 -> 0 bytes 66 files changed, 336 insertions(+), 574 deletions(-) create mode 100644 README.md rename src/main/java/ast/expressions/binaryexpressions/{DotSubstractionNode.java => DotSubtractionNode.java} (70%) delete mode 100644 src/main/java/ast/literal/BooleanLiteralNode.java delete mode 100644 src/main/java/ast/literal/CharLiteralNode.java delete mode 100644 src/main/java/ast/literal/LiteralNode.java delete mode 100644 src/main/java/ast/statements/BlockStatementNode.java rename src/main/java/{typechecker => semantic}/TypeCheckResult.java (72%) delete mode 100644 src/test/java/parser/ParserTest.java delete mode 100644 src/test/java/parser/ScannerTest.java delete mode 100644 src/test/java/semantic/BeginnToTAST.java delete mode 100644 src/test/java/semantic/SemanticTest.java delete mode 100644 src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt$Car.class delete mode 100644 src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt.class diff --git a/README.md b/README.md new file mode 100644 index 0000000..a814238 --- /dev/null +++ b/README.md @@ -0,0 +1,104 @@ +# "Nicht Haskel 2.0" Java Compiler + +Realisation of a subset of the Java Standard Compiler in the course Compiler Construction of the 4th semester Computer Science at the Duale Hochschule Suttgart (Horb). + +This project aims to provide a simplified version of the Java compiler, focusing on key language features and demonstrating the principles of compiler construction. + +## Realised Java syntax + +- **Data types**: `int`, `boolean`, `char` +- **Access modifier**: `public`, `protected`, `private` +- **Operators**: `=` `+` `-` `*` `%` `/` `>` `<` `>=` `<=` `==` `!=` `!` `&&` `||` `++` `--` +- **Keywords**: `class`, `this`, `while`, `do`, `if`, `else`, `for`, `return`, `new`, `switch`, `case`, `break`, `default`, `:` +- **Statements**: + - `if` ... `if else` ... `else`; + - `while` ... ; + - `do` ... `while`; + - `for`; + - `switch` ... `case` ... ; +- **Comments**: + - Single line: `// comment` + - Multi-line: `/* comment */` +- **Further functions**: + - All methods are overloadable + - High maintainability and expandability through implementation of the visitor pattern + - Logging Input and Outputs + - Error Handling in the Semantic Check + +## Project Structure + +```plain +src/ +└── main/ + ├── java/ + │ ├── ast/ -> Defining the structure of the AST + │ ├── bytecode/ -> Generate Java bytecode + │ ├── main/ -> Running the compiler + │ ├── parser/ + │ │ ├── astBuilder/ -> Builder creating the AST + │ │ ├── generated/ -> Antlr generated grammar + │ │ └── grammar/ -> Antlr grammar + │ ├── semantic/ -> Running the semantic check + │ └── visitor/ -> Visitor interface + └── resources/ +test/ +└── java/ + │ ├── main/ -> Running E2E tests + │ ├── parser/ -> Performs tests on the parser + │ ├── semantic/ -> Performs tests on the semantic check + └── resources/ -> Ressources for running the Tests +``` + +## Class-Diagramm AST + +![AST Diagramm](ast.png) + +## Distribution of the realisation + +### i22030 & i22035 + +Parser: +- Grammar -> (src/main/java/parser/grammar) +- Scanner +- Parser +- Abstract Syntax Tree (AST) -> (src/main/java/ast) +- AstBuilder -> (src/main/java/parser/astBuilder) + +Parser tests: +- ParserTests -> (src/test/java/parser) +- TestCases -> (src/test/resources/input/singeFeatureTests) + +Other: +- Documentation -> (README.md) +- Ast Class-Diagramm -> (ast.png) +- PowerPoint + +### i22005 +Semantic check: +- Set all types and check whether types have been used correctly +- Contexts -> (src/main/java/semantic/context) +- Exceptions Handling -> (src/main/java/semantic/exceptions) + +Semantic Tests: +- Typing and Type checking -> (src/test/java/semantic/EndToTypedAstTest) +- Exception and feature test -> (src/test/resources/input/typedAstExceptionsTests) + +### i22007 +Bytecode generation: +- Complete bytecode generation -> (src/mein/java/bytecode) + +### i22011 +Tests and execution: +- Makefile +- Running Compiler -> (src/main/main) +- Running E2E tests -> (src/test/main) +- Typing and Type checking -> (src/test/java/semantic/EndToTypedAstTest) + + + +## Used Tools + +- [Maven 4.0](https://maven.apache.org/index.html) + - Used for automating the build process and managing dependencies. +- [ANTLR4 v.13.1](https://www.antlr.org/) + - Used to parse the input Java code into the Abstract Syntax Tree. \ No newline at end of file diff --git a/src/main/java/ast/ASTNode.java b/src/main/java/ast/ASTNode.java index 1b666e2..8ebf41d 100644 --- a/src/main/java/ast/ASTNode.java +++ b/src/main/java/ast/ASTNode.java @@ -1,20 +1,6 @@ package ast; -import bytecode.visitor.ClassVisitor; -import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; - public interface ASTNode { - - //Todo: @BruderJohn & @i22007 Interface anwenden + geeignetetn Methodename. - - /* - Typecheck: - public TypeCheckResult acceptType(SemanticVisitor visitor); - - Bytecode: - public void accepByteCode(ClassVisitor classVisitor); - */ } diff --git a/src/main/java/ast/ClassNode.java b/src/main/java/ast/ClassNode.java index 6060237..4ea826e 100644 --- a/src/main/java/ast/ClassNode.java +++ b/src/main/java/ast/ClassNode.java @@ -1,12 +1,11 @@ package ast; import ast.type.AccessModifierNode; -import ast.members.ConstructorNode; import ast.members.MemberNode; import ast.members.MethodNode; import bytecode.visitor.ClassVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; import java.util.ArrayList; @@ -17,11 +16,11 @@ public class ClassNode implements ASTNode, Visitable { public String identifier; public List members = new ArrayList<>(); - public ClassNode(){ + public ClassNode() { } - public ClassNode(String accessType, String identifier){ + public ClassNode(String accessType, String identifier) { this.accessType = new AccessModifierNode(accessType); this.identifier = identifier; } @@ -30,7 +29,7 @@ public class ClassNode implements ASTNode, Visitable { members.add(member); } - public List getMethods(){ + public List getMethods() { List methods = new ArrayList<>(); for (MemberNode member : members) { if (member instanceof MethodNode methodNode) { diff --git a/src/main/java/ast/ProgramNode.java b/src/main/java/ast/ProgramNode.java index f8ad19a..ed7eee9 100644 --- a/src/main/java/ast/ProgramNode.java +++ b/src/main/java/ast/ProgramNode.java @@ -2,7 +2,7 @@ package ast; import bytecode.visitor.ProgramVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; import java.util.ArrayList; diff --git a/src/main/java/ast/expressions/binaryexpressions/BinaryNode.java b/src/main/java/ast/expressions/binaryexpressions/BinaryNode.java index 40b474a..82a7021 100644 --- a/src/main/java/ast/expressions/binaryexpressions/BinaryNode.java +++ b/src/main/java/ast/expressions/binaryexpressions/BinaryNode.java @@ -4,12 +4,12 @@ import ast.expressions.IExpressionNode; import ast.type.type.*; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; public class BinaryNode implements IExpressionNode, Visitable { - private ITypeNode typeNode; + public ITypeNode typeNode; @Override public TypeCheckResult accept(SemanticVisitor visitor) { diff --git a/src/main/java/ast/expressions/binaryexpressions/CalculationNode.java b/src/main/java/ast/expressions/binaryexpressions/CalculationNode.java index 9a2cc13..3c6617f 100644 --- a/src/main/java/ast/expressions/binaryexpressions/CalculationNode.java +++ b/src/main/java/ast/expressions/binaryexpressions/CalculationNode.java @@ -1,15 +1,13 @@ package ast.expressions.binaryexpressions; -import ast.type.type.*; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class CalculationNode extends BinaryNode { public CalculationNode calculationExpression; public EnumLineOperator operator; public DotNode dotExpression; - private ITypeNode typeNode; public CalculationNode(CalculationNode calculationExpression, String operator, DotNode dotExpression) { this.calculationExpression = calculationExpression; @@ -21,11 +19,11 @@ public class CalculationNode extends BinaryNode { this.dotExpression = dotExpression; } - private void setOperator(String operator) { - if(operator != null) { - if(operator.equals("+")) { + public void setOperator(String operator) { + if (operator != null) { + if (operator.equals("+")) { this.operator = EnumLineOperator.PLUS; - } else if(operator.equals("-")) { + } else if (operator.equals("-")) { this.operator = EnumLineOperator.MINUS; } } diff --git a/src/main/java/ast/expressions/binaryexpressions/DotNode.java b/src/main/java/ast/expressions/binaryexpressions/DotNode.java index 8e9c183..518f004 100644 --- a/src/main/java/ast/expressions/binaryexpressions/DotNode.java +++ b/src/main/java/ast/expressions/binaryexpressions/DotNode.java @@ -2,30 +2,28 @@ package ast.expressions.binaryexpressions; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class DotNode extends BinaryNode { public DotNode dotExpression; public EnumDotOperator operator; - public DotSubstractionNode dotSubstractionExpression; + public DotSubtractionNode dotSubtractionExpression; - public DotNode(DotNode dotExpression, String operator, DotSubstractionNode dotSubstractionExpression) { + public DotNode(DotNode dotExpression, String operator, DotSubtractionNode dotSubtractionExpression) { this.dotExpression = dotExpression; setOperator(operator); - this.dotSubstractionExpression = dotSubstractionExpression; + this.dotSubtractionExpression = dotSubtractionExpression; } - public DotNode(DotSubstractionNode dotSubstractionExpression) { - this.dotSubstractionExpression = dotSubstractionExpression; + public DotNode(DotSubtractionNode dotSubtractionExpression) { + this.dotSubtractionExpression = dotSubtractionExpression; } - private void setOperator(String operator) { - if(operator.equals("*")) { - this.operator = EnumDotOperator.MULT; - } else if(operator.equals("/")) { - this.operator = EnumDotOperator.DIV; - } else if(operator.equals("%")) { - this.operator = EnumDotOperator.MOD; + public void setOperator(String operator) { + switch (operator) { + case "*" -> this.operator = EnumDotOperator.MULT; + case "/" -> this.operator = EnumDotOperator.DIV; + case "%" -> this.operator = EnumDotOperator.MOD; } } diff --git a/src/main/java/ast/expressions/binaryexpressions/DotSubstractionNode.java b/src/main/java/ast/expressions/binaryexpressions/DotSubtractionNode.java similarity index 70% rename from src/main/java/ast/expressions/binaryexpressions/DotSubstractionNode.java rename to src/main/java/ast/expressions/binaryexpressions/DotSubtractionNode.java index a93d1c4..e2c64b5 100644 --- a/src/main/java/ast/expressions/binaryexpressions/DotSubstractionNode.java +++ b/src/main/java/ast/expressions/binaryexpressions/DotSubtractionNode.java @@ -1,45 +1,44 @@ -package ast.expressions.binaryexpressions; - -import ast.expressions.unaryexpressions.MemberAccessNode; -import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; -import ast.type.type.*; -import ast.type.ValueNode; -import bytecode.visitor.MethodVisitor; -import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; - -public class DotSubstractionNode extends BinaryNode { - public ValueNode value; - public String identifier; - public MemberAccessNode memberAccess; - public MethodCallNode methodCall; - public CalculationNode calculationExpression; - - public DotSubstractionNode(ValueNode value) { - this.value = value; - } - - public DotSubstractionNode(String identifier) { - this.identifier = identifier; - } - - public DotSubstractionNode(MemberAccessNode memberAccess) { - this.memberAccess = memberAccess; - } - - public DotSubstractionNode(MethodCallNode methodCall, CalculationNode calculationExpression) { - this.methodCall = methodCall; - this.calculationExpression = calculationExpression; - } - - @Override - public TypeCheckResult accept(SemanticVisitor visitor) { - return visitor.analyze(this); - } - - @Override - public void accept(MethodVisitor methodVisitor) { - methodVisitor.visit(this); - } - -} +package ast.expressions.binaryexpressions; + +import ast.expressions.unaryexpressions.MemberAccessNode; +import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; +import ast.type.ValueNode; +import bytecode.visitor.MethodVisitor; +import semantic.SemanticVisitor; +import semantic.TypeCheckResult; + +public class DotSubtractionNode extends BinaryNode { + public ValueNode value; + public String identifier; + public MemberAccessNode memberAccess; + public MethodCallNode methodCall; + public CalculationNode calculationExpression; + + public DotSubtractionNode(ValueNode value) { + this.value = value; + } + + public DotSubtractionNode(String identifier) { + this.identifier = identifier; + } + + public DotSubtractionNode(MemberAccessNode memberAccess) { + this.memberAccess = memberAccess; + } + + public DotSubtractionNode(MethodCallNode methodCall, CalculationNode calculationExpression) { + this.methodCall = methodCall; + this.calculationExpression = calculationExpression; + } + + @Override + public TypeCheckResult accept(SemanticVisitor visitor) { + return visitor.analyze(this); + } + + @Override + public void accept(MethodVisitor methodVisitor) { + methodVisitor.visit(this); + } + +} diff --git a/src/main/java/ast/expressions/binaryexpressions/NonCalculationNode.java b/src/main/java/ast/expressions/binaryexpressions/NonCalculationNode.java index c44a103..ae63b01 100644 --- a/src/main/java/ast/expressions/binaryexpressions/NonCalculationNode.java +++ b/src/main/java/ast/expressions/binaryexpressions/NonCalculationNode.java @@ -2,10 +2,9 @@ package ast.expressions.binaryexpressions; import ast.expressions.IExpressionNode; import ast.expressions.unaryexpressions.UnaryNode; -import ast.type.type.*; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class NonCalculationNode extends BinaryNode { public UnaryNode unaryExpression; @@ -18,23 +17,16 @@ public class NonCalculationNode extends BinaryNode { this.expression = expression; } - private void setOperator(String operator) { - if(operator.equals("&&")) { - this.operator = EnumNonCalculationOperator.AND; - } else if(operator.equals("||")) { - this.operator = EnumNonCalculationOperator.OR; - } else if(operator.equals(">")) { - this.operator = EnumNonCalculationOperator.GREATER; - } else if(operator.equals("<")) { - this.operator = EnumNonCalculationOperator.LESS; - } else if(operator.equals(">=")) { - this.operator = EnumNonCalculationOperator.GREATER_EQUAL; - } else if(operator.equals("<=")) { - this.operator = EnumNonCalculationOperator.LESS_EQUAL; - } else if(operator.equals("==")) { - this.operator = EnumNonCalculationOperator.EQUAL; - } else if(operator.equals("!=")) { - this.operator = EnumNonCalculationOperator.NOT_EQUAL; + public void setOperator(String operator) { + switch (operator) { + case "&&" -> this.operator = EnumNonCalculationOperator.AND; + case "||" -> this.operator = EnumNonCalculationOperator.OR; + case ">" -> this.operator = EnumNonCalculationOperator.GREATER; + case "<" -> this.operator = EnumNonCalculationOperator.LESS; + case ">=" -> this.operator = EnumNonCalculationOperator.GREATER_EQUAL; + case "<=" -> this.operator = EnumNonCalculationOperator.LESS_EQUAL; + case "==" -> this.operator = EnumNonCalculationOperator.EQUAL; + case "!=" -> this.operator = EnumNonCalculationOperator.NOT_EQUAL; } } diff --git a/src/main/java/ast/expressions/unaryexpressions/MemberAccessNode.java b/src/main/java/ast/expressions/unaryexpressions/MemberAccessNode.java index ca688db..29de4dd 100644 --- a/src/main/java/ast/expressions/unaryexpressions/MemberAccessNode.java +++ b/src/main/java/ast/expressions/unaryexpressions/MemberAccessNode.java @@ -2,9 +2,9 @@ package ast.expressions.unaryexpressions; import ast.ASTNode; import bytecode.visitor.MethodVisitor; -import ast.type.type.ITypeNode; + import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; import java.util.ArrayList; @@ -13,7 +13,6 @@ import java.util.List; public class MemberAccessNode implements ASTNode, Visitable { public Boolean thisExpr; public List identifiers = new ArrayList<>(); - private ITypeNode typeNode; public MemberAccessNode(Boolean thisExpr) { this.thisExpr = thisExpr; @@ -27,17 +26,10 @@ public class MemberAccessNode implements ASTNode, Visitable { public void accept(MethodVisitor methodVisitor) { methodVisitor.visit(this); } - + public TypeCheckResult accept(SemanticVisitor visitor) { return visitor.analyze(this); } - public ITypeNode getTypeNode() { - return typeNode; - } - - public void setTypeNode(ITypeNode typeNode) { - this.typeNode = typeNode; - } } diff --git a/src/main/java/ast/expressions/unaryexpressions/NotNode.java b/src/main/java/ast/expressions/unaryexpressions/NotNode.java index e0c31a3..eb651ff 100644 --- a/src/main/java/ast/expressions/unaryexpressions/NotNode.java +++ b/src/main/java/ast/expressions/unaryexpressions/NotNode.java @@ -1,13 +1,12 @@ package ast.expressions.unaryexpressions; -import ast.ASTNode; import ast.expressions.IExpressionNode; +import ast.type.type.ITypeNode; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; -import visitor.Visitable; +import semantic.TypeCheckResult; -public class NotNode implements ASTNode, Visitable { +public class NotNode implements IExpressionNode { public IExpressionNode expression; public NotNode(IExpressionNode expression) { @@ -24,4 +23,13 @@ public class NotNode implements ASTNode, Visitable { return null; } -} + @Override + public ITypeNode getType() { + return expression.getType(); + } + + @Override + public void setType(ITypeNode type) { + this.expression.setType(type); + } +} \ No newline at end of file diff --git a/src/main/java/ast/expressions/unaryexpressions/UnaryNode.java b/src/main/java/ast/expressions/unaryexpressions/UnaryNode.java index 21374fa..cd4dd38 100644 --- a/src/main/java/ast/expressions/unaryexpressions/UnaryNode.java +++ b/src/main/java/ast/expressions/unaryexpressions/UnaryNode.java @@ -6,7 +6,7 @@ import ast.type.type.*; import ast.type.ValueNode; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import java.util.Objects; @@ -18,10 +18,10 @@ public class UnaryNode implements IExpressionNode { public NotNode notExpression; public IStatementNode statement; public IExpressionNode expression; - private ITypeNode type; + public ITypeNode type; public UnaryNode(String value) { - if(Objects.equals(value, "this")) { + if (Objects.equals(value, "this")) { this.thisExp = "this"; } else { this.identifier = value; diff --git a/src/main/java/ast/literal/BooleanLiteralNode.java b/src/main/java/ast/literal/BooleanLiteralNode.java deleted file mode 100644 index 4657df7..0000000 --- a/src/main/java/ast/literal/BooleanLiteralNode.java +++ /dev/null @@ -1,11 +0,0 @@ -package ast.literal; - -public class BooleanLiteralNode { - private String value; - - public BooleanLiteralNode(String value) {this.value = value;} - - public String getValue() { - return value; - } -} diff --git a/src/main/java/ast/literal/CharLiteralNode.java b/src/main/java/ast/literal/CharLiteralNode.java deleted file mode 100644 index c77c073..0000000 --- a/src/main/java/ast/literal/CharLiteralNode.java +++ /dev/null @@ -1,11 +0,0 @@ -package ast.literal; - -public class CharLiteralNode { - public String value; - - public CharLiteralNode(String value) {this.value = value;} - - public String getValue() { - return value; - } -} diff --git a/src/main/java/ast/literal/LiteralNode.java b/src/main/java/ast/literal/LiteralNode.java deleted file mode 100644 index 43a16f9..0000000 --- a/src/main/java/ast/literal/LiteralNode.java +++ /dev/null @@ -1,31 +0,0 @@ -package ast.literal; - -import ast.expressions.IExpressionNode; -import ast.type.type.ITypeNode; -import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; - -public class LiteralNode implements IExpressionNode { - - public String value; - private ITypeNode type; - - public LiteralNode(String value, ITypeNode type) { - this.value = value; - this.type = type; - } - - public ITypeNode getType() { - return type; - } - - public void setType(ITypeNode type) { - this.type = type; - } - - - @Override - public TypeCheckResult accept(SemanticVisitor visitor) { - return null; - } -} \ No newline at end of file diff --git a/src/main/java/ast/members/ConstructorNode.java b/src/main/java/ast/members/ConstructorNode.java index 2ff9f94..e149fc6 100644 --- a/src/main/java/ast/members/ConstructorNode.java +++ b/src/main/java/ast/members/ConstructorNode.java @@ -32,8 +32,7 @@ public class ConstructorNode extends MethodNode implements Visitable { } public boolean isSame(MethodNode methodNode) { - if (!(Objects.equals(this.identifier, methodNode.getIdentifier())) - || getParameters().size() != methodNode.getParameters().size()) { + if (!(Objects.equals(this.identifier, methodNode.getIdentifier())) || getParameters().size() != methodNode.getParameters().size()) { return false; } diff --git a/src/main/java/ast/members/FieldNode.java b/src/main/java/ast/members/FieldNode.java index edf434c..e223b25 100644 --- a/src/main/java/ast/members/FieldNode.java +++ b/src/main/java/ast/members/FieldNode.java @@ -3,9 +3,8 @@ package ast.members; import ast.type.AccessModifierNode; import ast.type.type.ITypeNode; import bytecode.visitor.ClassVisitor; -import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; public class FieldNode implements MemberNode, Visitable { @@ -13,7 +12,7 @@ public class FieldNode implements MemberNode, Visitable { public ITypeNode type; public String identifier; - public FieldNode(AccessModifierNode accessTypeNode, ITypeNode type, String name){ + public FieldNode(AccessModifierNode accessTypeNode, ITypeNode type, String name) { this.accessTypeNode = accessTypeNode; this.type = type; this.identifier = name; diff --git a/src/main/java/ast/members/MemberNode.java b/src/main/java/ast/members/MemberNode.java index 1319c03..6f8bcc8 100644 --- a/src/main/java/ast/members/MemberNode.java +++ b/src/main/java/ast/members/MemberNode.java @@ -10,7 +10,8 @@ import ast.ASTNode; @JsonSubTypes({ @JsonSubTypes.Type(value = MethodNode.class, name = "Method"), - @JsonSubTypes.Type(value = FieldNode.class, name = "Field") } + @JsonSubTypes.Type(value = FieldNode.class, name = "Field")} ) -public interface MemberNode extends ASTNode {} +public interface MemberNode extends ASTNode { +} diff --git a/src/main/java/ast/members/MethodNode.java b/src/main/java/ast/members/MethodNode.java index 46a654d..316f77c 100644 --- a/src/main/java/ast/members/MethodNode.java +++ b/src/main/java/ast/members/MethodNode.java @@ -6,7 +6,7 @@ import ast.type.AccessModifierNode; import ast.type.type.*; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; import java.util.ArrayList; @@ -15,16 +15,16 @@ import java.util.Objects; public class MethodNode implements MemberNode, Visitable { public AccessModifierNode accesModifier; - private ITypeNode type; + public ITypeNode type; public Boolean voidType; - private String identifier; + public String identifier; public List parameters = new ArrayList<>(); public BlockNode block; public MethodNode() { } - public MethodNode(String accessModifier, ITypeNode type, Boolean voidType, String identifier, BlockNode block){ + public MethodNode(String accessModifier, ITypeNode type, Boolean voidType, String identifier, BlockNode block) { this.accesModifier = new AccessModifierNode(accessModifier); this.type = type; this.voidType = voidType; @@ -40,7 +40,7 @@ public class MethodNode implements MemberNode, Visitable { return parameters; } - public boolean isSame(MethodNode methodNode){ + public boolean isSame(MethodNode methodNode) { if (!(Objects.equals(this.identifier, methodNode.getIdentifier())) || type.equals(methodNode.type) || getParameters().size() != methodNode.getParameters().size()) { return false; diff --git a/src/main/java/ast/parameters/ParameterNode.java b/src/main/java/ast/parameters/ParameterNode.java index f3ec9bd..d3a0713 100644 --- a/src/main/java/ast/parameters/ParameterNode.java +++ b/src/main/java/ast/parameters/ParameterNode.java @@ -3,7 +3,7 @@ package ast.parameters; import ast.ASTNode; import ast.type.type.*; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; public class ParameterNode implements ASTNode, Visitable { diff --git a/src/main/java/ast/statementexpressions/AssignNode.java b/src/main/java/ast/statementexpressions/AssignNode.java index c620abd..c181e04 100644 --- a/src/main/java/ast/statementexpressions/AssignNode.java +++ b/src/main/java/ast/statementexpressions/AssignNode.java @@ -3,7 +3,7 @@ package ast.statementexpressions; import ast.expressions.IExpressionNode; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class AssignNode implements IStatementExpressionNode { public AssignableNode assignable; diff --git a/src/main/java/ast/statementexpressions/AssignableNode.java b/src/main/java/ast/statementexpressions/AssignableNode.java index 83568d8..aaa8406 100644 --- a/src/main/java/ast/statementexpressions/AssignableNode.java +++ b/src/main/java/ast/statementexpressions/AssignableNode.java @@ -3,11 +3,11 @@ package ast.statementexpressions; import ast.expressions.unaryexpressions.MemberAccessNode; import ast.type.type.ITypeNode; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class AssignableNode implements IStatementExpressionNode { public String identifier; - private ITypeNode typeNode; + public ITypeNode typeNode; public MemberAccessNode memberAccess; @@ -24,10 +24,6 @@ public class AssignableNode implements IStatementExpressionNode { return visitor.analyze(this); } - public ITypeNode getTypeNode() { - return typeNode; - } - public void setTypeNode(ITypeNode typeNode) { this.typeNode = typeNode; } diff --git a/src/main/java/ast/statementexpressions/IStatementExpressionNode.java b/src/main/java/ast/statementexpressions/IStatementExpressionNode.java index 7458848..0a56216 100644 --- a/src/main/java/ast/statementexpressions/IStatementExpressionNode.java +++ b/src/main/java/ast/statementexpressions/IStatementExpressionNode.java @@ -2,4 +2,5 @@ package ast.statementexpressions; import ast.statements.IStatementNode; -public interface IStatementExpressionNode extends IStatementNode {} +public interface IStatementExpressionNode extends IStatementNode { +} diff --git a/src/main/java/ast/statementexpressions/NewDeclarationNode.java b/src/main/java/ast/statementexpressions/NewDeclarationNode.java index 0964a6c..c822ace 100644 --- a/src/main/java/ast/statementexpressions/NewDeclarationNode.java +++ b/src/main/java/ast/statementexpressions/NewDeclarationNode.java @@ -3,7 +3,7 @@ package ast.statementexpressions; import ast.expressions.IExpressionNode; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java b/src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java index 8308e07..fb541de 100644 --- a/src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java +++ b/src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java @@ -2,10 +2,8 @@ package ast.statementexpressions.crementexpressions; import ast.statementexpressions.AssignableNode; import ast.statementexpressions.IStatementExpressionNode; -import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; -import visitor.Visitable; +import semantic.TypeCheckResult; public class DecrementNode implements IStatementExpressionNode { public CrementType crementType; diff --git a/src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java b/src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java index d736d3f..1a0c8cd 100644 --- a/src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java +++ b/src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java @@ -2,9 +2,8 @@ package ast.statementexpressions.crementexpressions; import ast.statementexpressions.AssignableNode; import ast.statementexpressions.IStatementExpressionNode; -import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class IncrementNode implements IStatementExpressionNode { public CrementType crementType; diff --git a/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java b/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java index ae01b85..abad5b0 100644 --- a/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java +++ b/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java @@ -4,7 +4,7 @@ import ast.ASTNode; import ast.expressions.IExpressionNode; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; import java.util.ArrayList; diff --git a/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/MethodCallNode.java b/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/MethodCallNode.java index 8179b82..82f113c 100644 --- a/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/MethodCallNode.java +++ b/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/MethodCallNode.java @@ -5,7 +5,7 @@ import ast.statements.IStatementNode; import ast.type.type.ITypeNode; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/TargetNode.java b/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/TargetNode.java index fbd0c08..6e3dc2b 100644 --- a/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/TargetNode.java +++ b/src/main/java/ast/statementexpressions/methodcallstatementnexpressions/TargetNode.java @@ -3,9 +3,8 @@ package ast.statementexpressions.methodcallstatementnexpressions; import ast.ASTNode; import ast.expressions.unaryexpressions.MemberAccessNode; import ast.statementexpressions.NewDeclarationNode; -import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; public class TargetNode implements ASTNode, Visitable { diff --git a/src/main/java/ast/statements/BlockNode.java b/src/main/java/ast/statements/BlockNode.java index 7a5a2ea..574fda1 100644 --- a/src/main/java/ast/statements/BlockNode.java +++ b/src/main/java/ast/statements/BlockNode.java @@ -1,8 +1,7 @@ package ast.statements; -import ast.ASTNode; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; import java.util.ArrayList; @@ -11,7 +10,8 @@ import java.util.List; public class BlockNode implements IStatementNode, Visitable { public List statements = new ArrayList<>(); - public BlockNode() {} + public BlockNode() { + } public void addStatement(IStatementNode statement) { statements.add(statement); diff --git a/src/main/java/ast/statements/BlockStatementNode.java b/src/main/java/ast/statements/BlockStatementNode.java deleted file mode 100644 index 8a01783..0000000 --- a/src/main/java/ast/statements/BlockStatementNode.java +++ /dev/null @@ -1,10 +0,0 @@ -package ast.statements; - - -import java.util.List; - -public class BlockStatementNode { - List statements; - - public BlockStatementNode(List statements) {this.statements = statements;} -} diff --git a/src/main/java/ast/statements/ElseNode.java b/src/main/java/ast/statements/ElseNode.java index 96e579e..5f5b550 100644 --- a/src/main/java/ast/statements/ElseNode.java +++ b/src/main/java/ast/statements/ElseNode.java @@ -1,7 +1,7 @@ package ast.statements; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class ElseNode implements IStatementNode { public BlockNode block; diff --git a/src/main/java/ast/statements/IfElseNode.java b/src/main/java/ast/statements/IfElseNode.java index 7126bed..9c4542a 100644 --- a/src/main/java/ast/statements/IfElseNode.java +++ b/src/main/java/ast/statements/IfElseNode.java @@ -1,7 +1,7 @@ package ast.statements; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/ast/statements/IfNode.java b/src/main/java/ast/statements/IfNode.java index 30e4e13..59ac7ca 100644 --- a/src/main/java/ast/statements/IfNode.java +++ b/src/main/java/ast/statements/IfNode.java @@ -2,7 +2,7 @@ package ast.statements; import ast.expressions.IExpressionNode; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class IfNode implements IStatementNode { public IExpressionNode expression; diff --git a/src/main/java/ast/statements/LocalVariableDeclarationNode.java b/src/main/java/ast/statements/LocalVariableDeclarationNode.java index 726ea24..032503f 100644 --- a/src/main/java/ast/statements/LocalVariableDeclarationNode.java +++ b/src/main/java/ast/statements/LocalVariableDeclarationNode.java @@ -4,7 +4,7 @@ import ast.expressions.IExpressionNode; import ast.type.type.*; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class LocalVariableDeclarationNode implements IStatementNode { public ITypeNode type; diff --git a/src/main/java/ast/statements/ReturnNode.java b/src/main/java/ast/statements/ReturnNode.java index fed9c44..485e0eb 100644 --- a/src/main/java/ast/statements/ReturnNode.java +++ b/src/main/java/ast/statements/ReturnNode.java @@ -3,14 +3,14 @@ package ast.statements; import ast.expressions.IExpressionNode; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class ReturnNode implements IStatementNode { public IExpressionNode expression; public Boolean voidReturn = false; public ReturnNode(IExpressionNode expression) { - if(expression != null) { + if (expression != null) { this.expression = expression; } else { voidReturn = true; diff --git a/src/main/java/ast/statements/WhileNode.java b/src/main/java/ast/statements/WhileNode.java index 6ac7f1f..08b3347 100644 --- a/src/main/java/ast/statements/WhileNode.java +++ b/src/main/java/ast/statements/WhileNode.java @@ -2,7 +2,7 @@ package ast.statements; import ast.expressions.IExpressionNode; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public class WhileNode implements IStatementNode { public IExpressionNode expression; @@ -14,7 +14,6 @@ public class WhileNode implements IStatementNode { } public void test() { - return; } diff --git a/src/main/java/ast/type/AccessModifierNode.java b/src/main/java/ast/type/AccessModifierNode.java index 45f9172..abb054a 100644 --- a/src/main/java/ast/type/AccessModifierNode.java +++ b/src/main/java/ast/type/AccessModifierNode.java @@ -8,7 +8,7 @@ public class AccessModifierNode { } private void setModifier(String accessType) { - switch(accessType) { + switch (accessType) { case "public": this.accessType = EnumAccessModifierNode.PUBLIC; break; diff --git a/src/main/java/ast/type/ValueNode.java b/src/main/java/ast/type/ValueNode.java index bf00e90..abf9c38 100644 --- a/src/main/java/ast/type/ValueNode.java +++ b/src/main/java/ast/type/ValueNode.java @@ -3,7 +3,7 @@ package ast.type; import ast.ASTNode; import bytecode.visitor.MethodVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; import visitor.Visitable; public class ValueNode implements ASTNode, Visitable { diff --git a/src/main/java/ast/type/type/BaseType.java b/src/main/java/ast/type/type/BaseType.java index 0563b64..8a5f21a 100644 --- a/src/main/java/ast/type/type/BaseType.java +++ b/src/main/java/ast/type/type/BaseType.java @@ -2,7 +2,7 @@ package ast.type.type; public class BaseType implements ITypeNode { - private TypeEnum typeEnum; + public final TypeEnum typeEnum; public BaseType(TypeEnum typeEnum) { this.typeEnum = typeEnum; @@ -21,8 +21,6 @@ public class BaseType implements ITypeNode { if (getClass() != obj.getClass()) return false; BaseType other = (BaseType) obj; - if (typeEnum != other.typeEnum) - return false; - return true; + return typeEnum == other.typeEnum; } } diff --git a/src/main/java/ast/type/type/ITypeNode.java b/src/main/java/ast/type/type/ITypeNode.java index e449e3c..098c3c2 100644 --- a/src/main/java/ast/type/type/ITypeNode.java +++ b/src/main/java/ast/type/type/ITypeNode.java @@ -1,5 +1,4 @@ package ast.type.type; public interface ITypeNode { - } diff --git a/src/main/java/ast/type/type/ReferenceType.java b/src/main/java/ast/type/type/ReferenceType.java index 2292046..bc54190 100644 --- a/src/main/java/ast/type/type/ReferenceType.java +++ b/src/main/java/ast/type/type/ReferenceType.java @@ -1,8 +1,8 @@ package ast.type.type; -public class ReferenceType implements ITypeNode{ +public class ReferenceType implements ITypeNode { - private String identifier; + public final String identifier; public ReferenceType(String identifier) { this.identifier = identifier; @@ -22,11 +22,8 @@ public class ReferenceType implements ITypeNode{ return false; ReferenceType other = (ReferenceType) obj; if (identifier == null) { - if (other.identifier != null) - return false; - } else if (!identifier.equals(other.identifier)) - return false; - return true; + return other.identifier == null; + } else return identifier.equals(other.identifier); } diff --git a/src/main/java/ast/type/type/TypeEnum.java b/src/main/java/ast/type/type/TypeEnum.java index d46fac3..292800c 100644 --- a/src/main/java/ast/type/type/TypeEnum.java +++ b/src/main/java/ast/type/type/TypeEnum.java @@ -4,6 +4,5 @@ public enum TypeEnum { VOID, INT, CHAR, - BOOL; - + BOOL } diff --git a/src/main/java/bytecode/ByteCodeGenerator.java b/src/main/java/bytecode/ByteCodeGenerator.java index dc47a4f..9978ec7 100644 --- a/src/main/java/bytecode/ByteCodeGenerator.java +++ b/src/main/java/bytecode/ByteCodeGenerator.java @@ -17,9 +17,9 @@ public class ByteCodeGenerator implements ProgramVisitor { private JarOutputStream jarOutputStream; private ByteArrayOutputStream byteArrayOutputStream; - private String outputDirectory; - private boolean generateJar; - private boolean generateClassFiles; + private final String outputDirectory; + private final boolean generateJar; + private final boolean generateClassFiles; public ByteCodeGenerator(String outputDirectory, boolean generateJar, boolean generateClassFiles) { this.outputDirectory = outputDirectory; diff --git a/src/main/java/bytecode/ClassCodeGen.java b/src/main/java/bytecode/ClassCodeGen.java index e7475f1..fd86cf7 100644 --- a/src/main/java/bytecode/ClassCodeGen.java +++ b/src/main/java/bytecode/ClassCodeGen.java @@ -19,12 +19,12 @@ import java.util.jar.JarOutputStream; public class ClassCodeGen implements ClassVisitor { - private Mapper mapper; + private final Mapper mapper; private ClassWriter classWriter; - private JarOutputStream jarOutputStream; - private String outputDirectory; - private boolean generateJar; - private boolean generateClassFiles; + private final JarOutputStream jarOutputStream; + private final String outputDirectory; + private final boolean generateJar; + private final boolean generateClassFiles; public ClassCodeGen(JarOutputStream jarOutputStream, String outputDirectory, boolean generateJar, boolean generateClassFiles) { mapper = new Mapper(); diff --git a/src/main/java/bytecode/MethodCodeGen.java b/src/main/java/bytecode/MethodCodeGen.java index 2744732..86d8f45 100644 --- a/src/main/java/bytecode/MethodCodeGen.java +++ b/src/main/java/bytecode/MethodCodeGen.java @@ -16,7 +16,6 @@ import ast.statementexpressions.crementexpressions.DecrementNode; import ast.statementexpressions.crementexpressions.IncrementNode; import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNode; import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; -import ast.statementexpressions.methodcallstatementnexpressions.TargetNode; import ast.statements.*; import ast.type.ValueNode; import ast.type.type.BaseType; @@ -35,11 +34,11 @@ import static org.objectweb.asm.Opcodes.*; public class MethodCodeGen implements bytecode.visitor.MethodVisitor { - private ClassWriter classWriter; - private Mapper mapper; + private final ClassWriter classWriter; + private final Mapper mapper; private MethodVisitor methodVisitor; - private List localVariables; + private final List localVariables; public MethodCodeGen(ClassWriter classWriter) { this.classWriter = classWriter; @@ -158,8 +157,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor { if (dotNode.dotExpression != null) { dotNode.dotExpression.accept(this); } - if (dotNode.dotSubstractionExpression != null) { - dotNode.dotSubstractionExpression.accept(this); + if (dotNode.dotSubtractionExpression != null) { + dotNode.dotSubtractionExpression.accept(this); } if (dotNode.operator != null) { switch (dotNode.operator) { @@ -177,17 +176,17 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor { } @Override - public void visit(DotSubstractionNode dotSubstractionNode) { - if (dotSubstractionNode.value != null) { - dotSubstractionNode.value.accept(this); - } else if (dotSubstractionNode.identifier != null) { - methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(dotSubstractionNode.identifier)); - } else if (dotSubstractionNode.memberAccess != null) { - dotSubstractionNode.memberAccess.accept(this); - } else if (dotSubstractionNode.methodCall != null) { - dotSubstractionNode.methodCall.accept(this); - } else if (dotSubstractionNode.calculationExpression != null) { - dotSubstractionNode.calculationExpression.accept(this); + public void visit(DotSubtractionNode dotSubtractionNode) { + if (dotSubtractionNode.value != null) { + dotSubtractionNode.value.accept(this); + } else if (dotSubtractionNode.identifier != null) { + methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(dotSubtractionNode.identifier)); + } else if (dotSubtractionNode.memberAccess != null) { + dotSubtractionNode.memberAccess.accept(this); + } else if (dotSubtractionNode.methodCall != null) { + dotSubtractionNode.methodCall.accept(this); + } else if (dotSubtractionNode.calculationExpression != null) { + dotSubtractionNode.calculationExpression.accept(this); } } @@ -387,8 +386,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor { @Override public void visit(AssignNode assignNode) { // Process expression - if (assignNode.expression instanceof IncrementNode) { - IncrementNode incrementNode = (IncrementNode) assignNode.expression; + if (assignNode.expression instanceof IncrementNode incrementNode) { if (incrementNode.crementType.equals(CrementType.PREFIX)) { // ++i methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1); assign(assignNode); @@ -396,8 +394,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor { assign(assignNode); methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1); } - } else if (assignNode.expression instanceof DecrementNode) { - DecrementNode decrementNode = (DecrementNode) assignNode.expression; + } else if (assignNode.expression instanceof DecrementNode decrementNode) { if (decrementNode.crementType.equals(CrementType.PREFIX)) { methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), -1); assign(assignNode); diff --git a/src/main/java/bytecode/visitor/MethodVisitor.java b/src/main/java/bytecode/visitor/MethodVisitor.java index 89fbb64..5aa352a 100644 --- a/src/main/java/bytecode/visitor/MethodVisitor.java +++ b/src/main/java/bytecode/visitor/MethodVisitor.java @@ -8,46 +8,54 @@ import ast.members.ConstructorNode; import ast.members.MainMethodNode; import ast.members.MethodNode; import ast.statementexpressions.AssignNode; -import ast.statementexpressions.AssignableNode; import ast.statementexpressions.NewDeclarationNode; -import ast.statementexpressions.crementexpressions.DecrementNode; -import ast.statementexpressions.crementexpressions.IncrementNode; import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNode; import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; -import ast.statementexpressions.methodcallstatementnexpressions.TargetNode; import ast.statements.*; import ast.type.ValueNode; public interface MethodVisitor { // members void visit(ConstructorNode constructorNode); + void visit(MethodNode methodNode); + void visit(MainMethodNode mainMethodNode); // Binary expressions void visit(BinaryNode binaryNode); + void visit(CalculationNode calculationNode); + void visit(DotNode dotNode); - void visit(DotSubstractionNode dotSubstractionNode); + + void visit(DotSubtractionNode dotSubtractionNode); + void visit(NonCalculationNode nonCalculationNode); // Unary expressions void visit(MemberAccessNode memberAccessNode); + void visit(NotNode notExpressionNode); + void visit(UnaryNode unaryExpressionNode); // statements void visit(IfElseNode ifElseNode); void visit(LocalVariableDeclarationNode localVariableDeclarationNode); + void visit(ReturnNode returnNode); + void visit(WhileNode whileNode); // statement expression void visit(ChainedMethodNode chainedMethodNode); + void visit(MethodCallNode methodCallNode); void visit(AssignNode assignNode); + void visit(NewDeclarationNode newDeclarationNode); // type diff --git a/src/main/java/bytecode/visitor/ProgramVisitor.java b/src/main/java/bytecode/visitor/ProgramVisitor.java index d569ec6..857a9e0 100644 --- a/src/main/java/bytecode/visitor/ProgramVisitor.java +++ b/src/main/java/bytecode/visitor/ProgramVisitor.java @@ -3,5 +3,5 @@ package bytecode.visitor; import ast.ProgramNode; public interface ProgramVisitor { - void visit(ProgramNode programNode); + void visit(ProgramNode programNode); } diff --git a/src/main/java/parser/astBuilder/ASTBuilder.java b/src/main/java/parser/astBuilder/ASTBuilder.java index 7e8f0e0..ef409f6 100644 --- a/src/main/java/parser/astBuilder/ASTBuilder.java +++ b/src/main/java/parser/astBuilder/ASTBuilder.java @@ -211,8 +211,8 @@ public class ASTBuilder extends SimpleJavaBaseVisitor { WhileNode While = new WhileNode(condition, doBlock); BlockNode resultBlock = new BlockNode(); - resultBlock.addStatement((IStatementNode) doBlock); - resultBlock.addStatement((IStatementNode) While); + resultBlock.addStatement(doBlock); + resultBlock.addStatement(While); return resultBlock; } @@ -253,7 +253,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor { // Prä-Inkrement: Das Inkrement kommt vor dem Block if (crement != null && isPrefix) { - whileBody.addStatement((IStatementNode) crement); + whileBody.addStatement(crement); } // Block Statements der For-Schleife in den While-Block kopieren @@ -263,7 +263,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor { // Post-Inkrement: Das Inkrement kommt nach dem Block if (crement != null && !isPrefix) { - whileBody.addStatement((IStatementNode) crement); + whileBody.addStatement(crement); } // Bedingung der While-Schleife @@ -273,7 +273,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor { BlockNode resultBlock = new BlockNode(); for (IStatementNode statement : statements) { - resultBlock.addStatement((IStatementNode) statement); + resultBlock.addStatement(statement); } return resultBlock; @@ -559,9 +559,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor { @Override public ASTNode visitDotExpression(SimpleJavaParser.DotExpressionContext ctx) { if(ctx.dotExpression() != null) { - return new DotNode((DotNode) visit(ctx.dotExpression()), ctx.DotOperator().getText(), (DotSubstractionNode) visit(ctx.dotSubtractionExpression())); + return new DotNode((DotNode) visit(ctx.dotExpression()), ctx.DotOperator().getText(), (DotSubtractionNode) visit(ctx.dotSubtractionExpression())); } else if(ctx.dotSubtractionExpression() != null) { - return new DotNode((DotSubstractionNode) visit(ctx.dotSubtractionExpression())); + return new DotNode((DotSubtractionNode) visit(ctx.dotSubtractionExpression())); } return null; } @@ -569,13 +569,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor { @Override public ASTNode visitDotSubtractionExpression(SimpleJavaParser.DotSubtractionExpressionContext ctx) { if(ctx.IntValue() != null) { - return new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, ctx.IntValue().getText())); + return new DotSubtractionNode(new ValueNode(EnumValueNode.INT_VALUE, ctx.IntValue().getText())); } else if(ctx.Identifier() != null) { - return new DotSubstractionNode(ctx.Identifier().getText()); + return new DotSubtractionNode(ctx.Identifier().getText()); } else if(ctx.memberAccess() != null) { - return new DotSubstractionNode((MemberAccessNode) visit(ctx.memberAccess())); + return new DotSubtractionNode((MemberAccessNode) visit(ctx.memberAccess())); } else if(ctx.methodCall() != null && ctx.calculationExpression() != null) { - return new DotSubstractionNode((MethodCallNode) visit(ctx.methodCall()), (CalculationNode) visit(ctx.calculationExpression())); + return new DotSubtractionNode((MethodCallNode) visit(ctx.methodCall()), (CalculationNode) visit(ctx.calculationExpression())); } return null; } diff --git a/src/main/java/semantic/Scope.java b/src/main/java/semantic/Scope.java index b6b40c4..955e31f 100644 --- a/src/main/java/semantic/Scope.java +++ b/src/main/java/semantic/Scope.java @@ -8,7 +8,7 @@ import java.util.Stack; public class Scope { - private Stack> localVars; + private final Stack> localVars; public Scope() { localVars = new Stack>(); diff --git a/src/main/java/semantic/SemanticAnalyzer.java b/src/main/java/semantic/SemanticAnalyzer.java index bfc51cf..91ad3b7 100644 --- a/src/main/java/semantic/SemanticAnalyzer.java +++ b/src/main/java/semantic/SemanticAnalyzer.java @@ -25,19 +25,15 @@ import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNod import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; import ast.statementexpressions.methodcallstatementnexpressions.TargetNode; import ast.statements.*; -import ast.type.AccessModifierNode; import ast.type.EnumAccessModifierNode; import ast.type.ValueNode; import ast.type.type.*; -import com.sun.jdi.IntegerType; -import semantic.context.ClassContext; import semantic.context.Context; import semantic.exceptions.*; -import typechecker.TypeCheckResult; public class SemanticAnalyzer implements SemanticVisitor { - private static HashMap currentFields = new HashMap<>(); + private static final HashMap currentFields = new HashMap<>(); public static ArrayList errors = new ArrayList<>(); @@ -472,14 +468,14 @@ public class SemanticAnalyzer implements SemanticVisitor { @Override public TypeCheckResult analyze(DotNode toCheck) { - if (toCheck.dotSubstractionExpression != null) { - return toCheck.dotSubstractionExpression.accept(this); + if (toCheck.dotSubtractionExpression != null) { + return toCheck.dotSubtractionExpression.accept(this); } return new TypeCheckResult(false, null); } @Override - public TypeCheckResult analyze(DotSubstractionNode toCheck) { + public TypeCheckResult analyze(DotSubtractionNode toCheck) { if (toCheck.value != null) { return toCheck.value.accept(this); } else if (toCheck.memberAccess != null) { diff --git a/src/main/java/semantic/SemanticVisitor.java b/src/main/java/semantic/SemanticVisitor.java index 0c979ca..7d57189 100644 --- a/src/main/java/semantic/SemanticVisitor.java +++ b/src/main/java/semantic/SemanticVisitor.java @@ -15,7 +15,6 @@ import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; import ast.statementexpressions.methodcallstatementnexpressions.TargetNode; import ast.statements.*; import ast.type.ValueNode; -import typechecker.TypeCheckResult; public interface SemanticVisitor { @@ -61,7 +60,7 @@ public interface SemanticVisitor { TypeCheckResult analyze(DotNode toCheck); - TypeCheckResult analyze(DotSubstractionNode toCheck); + TypeCheckResult analyze(DotSubtractionNode toCheck); TypeCheckResult analyze(NonCalculationNode toCheck); diff --git a/src/main/java/typechecker/TypeCheckResult.java b/src/main/java/semantic/TypeCheckResult.java similarity index 72% rename from src/main/java/typechecker/TypeCheckResult.java rename to src/main/java/semantic/TypeCheckResult.java index f52818d..eb667ee 100644 --- a/src/main/java/typechecker/TypeCheckResult.java +++ b/src/main/java/semantic/TypeCheckResult.java @@ -1,23 +1,23 @@ -package typechecker; - - -import ast.type.type.ITypeNode; - -public class TypeCheckResult { - - private boolean valid; - private ITypeNode type; - - public TypeCheckResult(boolean valid, ITypeNode type) { - this.valid = valid; - this.type = type; - } - - public boolean isValid() { - return valid; - } - - public ITypeNode getType() { - return type; - } +package semantic; + + +import ast.type.type.ITypeNode; + +public class TypeCheckResult { + + private final boolean valid; + private final ITypeNode type; + + public TypeCheckResult(boolean valid, ITypeNode type) { + this.valid = valid; + this.type = type; + } + + public boolean isValid() { + return valid; + } + + public ITypeNode getType() { + return type; + } } \ No newline at end of file diff --git a/src/main/java/semantic/context/ClassContext.java b/src/main/java/semantic/context/ClassContext.java index b9e39a4..35600b0 100644 --- a/src/main/java/semantic/context/ClassContext.java +++ b/src/main/java/semantic/context/ClassContext.java @@ -9,8 +9,8 @@ import java.util.HashMap; public class ClassContext { - private HashMap fields; - private ArrayList methods = new ArrayList<>(); + private final HashMap fields; + private final ArrayList methods = new ArrayList<>(); public ClassContext(ClassNode classNode) { diff --git a/src/main/java/semantic/context/Context.java b/src/main/java/semantic/context/Context.java index 4b20c8f..cf4eb95 100644 --- a/src/main/java/semantic/context/Context.java +++ b/src/main/java/semantic/context/Context.java @@ -5,7 +5,7 @@ import java.util.HashMap; public class Context { - private HashMap classes; + private final HashMap classes; public Context(ProgramNode programNode) { classes = new HashMap<>(); diff --git a/src/main/java/semantic/context/FieldContext.java b/src/main/java/semantic/context/FieldContext.java index aba5ba0..8a32915 100644 --- a/src/main/java/semantic/context/FieldContext.java +++ b/src/main/java/semantic/context/FieldContext.java @@ -6,8 +6,8 @@ import ast.type.type.*; public class FieldContext { - private AccessModifierNode accessModifier; - private ITypeNode type; + private final AccessModifierNode accessModifier; + private final ITypeNode type; public FieldContext(FieldNode field) { accessModifier = field.accessTypeNode; diff --git a/src/main/java/visitor/Visitable.java b/src/main/java/visitor/Visitable.java index bd69777..6e22b41 100644 --- a/src/main/java/visitor/Visitable.java +++ b/src/main/java/visitor/Visitable.java @@ -4,7 +4,7 @@ import bytecode.visitor.ClassVisitor; import bytecode.visitor.MethodVisitor; import bytecode.visitor.ProgramVisitor; import semantic.SemanticVisitor; -import typechecker.TypeCheckResult; +import semantic.TypeCheckResult; public interface Visitable { default void accept(ProgramVisitor programVisitor) { diff --git a/src/test/java/parser/AstBuilderTest.java b/src/test/java/parser/AstBuilderTest.java index bc7d562..18ebc38 100644 --- a/src/test/java/parser/AstBuilderTest.java +++ b/src/test/java/parser/AstBuilderTest.java @@ -6,7 +6,7 @@ import ast.ProgramNode; import ast.expressions.IExpressionNode; import ast.expressions.binaryexpressions.CalculationNode; import ast.expressions.binaryexpressions.DotNode; -import ast.expressions.binaryexpressions.DotSubstractionNode; +import ast.expressions.binaryexpressions.DotSubtractionNode; import ast.expressions.binaryexpressions.NonCalculationNode; import ast.expressions.unaryexpressions.MemberAccessNode; import ast.expressions.unaryexpressions.UnaryNode; @@ -514,31 +514,31 @@ class AstBuilderTest { ClassNode class1 = Helper.generateEmptyClass("VariableCalculation"); BlockNode aPlusBBlock = new BlockNode(); - aPlusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "+", new DotNode(new DotSubstractionNode("b"))))); + aPlusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubtractionNode("a"))), "+", new DotNode(new DotSubtractionNode("b"))))); MethodNode aPlusBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aPlusB", aPlusBBlock); aPlusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); aPlusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b")); BlockNode aMinusBBlock = new BlockNode(); - aMinusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "-", new DotNode(new DotSubstractionNode("b"))))); + aMinusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubtractionNode("a"))), "-", new DotNode(new DotSubtractionNode("b"))))); MethodNode aMinusBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aMinusB", aMinusBBlock); aMinusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); aMinusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b")); BlockNode aTimeBBlock = new BlockNode(); - aTimeBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "*", new DotSubstractionNode("b"))))); + aTimeBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubtractionNode("a")), "*", new DotSubtractionNode("b"))))); MethodNode aTimeBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aTimeB", aTimeBBlock); aTimeBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); aTimeBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b")); BlockNode aDivBBlock = new BlockNode(); - aDivBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "/", new DotSubstractionNode("b"))))); + aDivBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubtractionNode("a")), "/", new DotSubtractionNode("b"))))); MethodNode aDivBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aDivB", aDivBBlock); aDivBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); aDivBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b")); BlockNode complexCalcBlock = new BlockNode(); - complexCalcBlock.addStatement(new ReturnNode(new CalculationNode(null, null, new DotNode(new DotNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "*", new DotSubstractionNode("b")), "/", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))), "*", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "3")))))); + complexCalcBlock.addStatement(new ReturnNode(new CalculationNode(null, null, new DotNode(new DotNode(new DotNode(new DotNode(new DotSubtractionNode("a")), "*", new DotSubtractionNode("b")), "/", new DotSubtractionNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))), "*", new DotSubtractionNode(new ValueNode(EnumValueNode.INT_VALUE, "3")))))); MethodNode complexCalcMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "complexCalc", complexCalcBlock); complexCalcMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); complexCalcMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b")); diff --git a/src/test/java/parser/Helper.java b/src/test/java/parser/Helper.java index a679c8a..63261f4 100644 --- a/src/test/java/parser/Helper.java +++ b/src/test/java/parser/Helper.java @@ -2,12 +2,10 @@ package parser; import ast.ASTNode; import ast.ClassNode; -import ast.ProgramNode; import ast.members.ConstructorNode; import ast.members.MemberNode; import ast.statements.BlockNode; import ast.statements.ReturnNode; -import ast.type.AccessModifierNode; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; @@ -39,7 +37,7 @@ public class Helper { public static ClassNode generateEmptyClass(String className) { BlockNode blockNode = new BlockNode(); blockNode.addStatement(new ReturnNode(null)); - MemberNode constructor = new ConstructorNode("public",className, blockNode); + MemberNode constructor = new ConstructorNode("public", className, blockNode); ClassNode classNode = new ClassNode("public", className); classNode.addMember(constructor); return classNode; diff --git a/src/test/java/parser/ParserTest.java b/src/test/java/parser/ParserTest.java deleted file mode 100644 index c567b4b..0000000 --- a/src/test/java/parser/ParserTest.java +++ /dev/null @@ -1,138 +0,0 @@ -package parser; - -import org.antlr.v4.runtime.*; -import org.antlr.v4.runtime.tree.ParseTree; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import parser.generated.SimpleJavaLexer; -import parser.generated.SimpleJavaParser; - -import static org.junit.jupiter.api.Assertions.*; - -import java.util.*; - -public class ParserTest { - /* - @BeforeEach - public void init() { // noch nicht benötigt - String inputFilePath = "src/main/resources/input/CompilerInput.java"; - String outputDirectoryPath = "src/main/resources/output"; - } - */ - - @Test - public void parserTest() { - // init - CharStream inputCharStream = CharStreams.fromString("public class Name {}"); - SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream); - CommonTokenStream tokenStream = new CommonTokenStream(lexer); - tokenStream.fill(); - - - /* Parser -> Parsetree */ - SimpleJavaParser parser = new SimpleJavaParser(tokenStream); - ParseTree parseTree = parser.program(); // parse the input - - //Variante 1 (geht) - String expectedParseTreeAsString = "(program (classDeclaration public class Name { }))"; - String actualParseTreeAsString = parseTree.toStringTree(parser); - - assertEquals(expectedParseTreeAsString, actualParseTreeAsString); - - // Variante 2 (geht nicht) - // - Sollte es gehen und es liegt am Parser? (keine Ahnung) -> Bitte Fehler (actual und expected) durchlesen - // ist die Methode parseStringToTree() korrekt? -> (glaub nicht) - Map expectedTreeStructure = parseStringToTree(expectedParseTreeAsString); - Map actualTreeStructure = buildTreeStructure(parseTree, parser); - - // assertEquals(expectedTreeStructure, actualTreeStructure); - } - - - - // Helpers Variante 2.1 - - public static Map buildTreeStructure(ParseTree tree, Parser parser) { - return buildTree(tree, parser, 0); - } - - private static Map buildTree(ParseTree tree, Parser parser, int indent) { - Map node = new HashMap<>(); - - if (tree instanceof RuleContext) { - int ruleIndex = ((RuleContext) tree).getRuleIndex(); - String ruleName = parser.getRuleNames()[ruleIndex]; - node.put("rule", ruleName); - } else { - node.put("text", tree.getText()); - } - - List> children = new ArrayList<>(); - for (int i = 0; i < tree.getChildCount(); i++) { - children.add(buildTree(tree.getChild(i), parser, indent + 1)); - } - - if (!children.isEmpty()) { - node.put("children", children); - } - - return node; - } - - // Helpers Variante 2.2 - - public static Map parseStringToTree(String input) { - input = input.trim(); - if (input.startsWith("(") && input.endsWith(")")) { - input = input.substring(1, input.length() - 1).trim(); - } - return parse(input); - } - - private static Map parse(String input) { - Map node = new HashMap<>(); - StringBuilder currentToken = new StringBuilder(); - List> children = new ArrayList<>(); - - int depth = 0; - boolean inToken = false; - for (char ch : input.toCharArray()) { - if (ch == '(') { - if (depth == 0) { - if (!currentToken.isEmpty()) { - node.put("node", currentToken.toString().trim()); - currentToken.setLength(0); - } - } else { - currentToken.append(ch); - } - depth++; - } else if (ch == ')') { - depth--; - if (depth == 0) { - children.add(parse(currentToken.toString().trim())); - currentToken.setLength(0); - } else { - currentToken.append(ch); - } - } else if (Character.isWhitespace(ch) && depth == 0) { - if (!currentToken.isEmpty()) { - node.put("node", currentToken.toString().trim()); - currentToken.setLength(0); - } - } else { - currentToken.append(ch); - } - } - - if (!currentToken.isEmpty()) { - node.put("node", currentToken.toString().trim()); - } - - if (!children.isEmpty()) { - node.put("children", children); - } - - return node; - } -} diff --git a/src/test/java/parser/ScannerTest.java b/src/test/java/parser/ScannerTest.java deleted file mode 100644 index ba31a81..0000000 --- a/src/test/java/parser/ScannerTest.java +++ /dev/null @@ -1,45 +0,0 @@ -package parser; - -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.CharStreams; -import org.antlr.v4.runtime.CommonTokenStream; -import org.antlr.v4.runtime.Token; -import org.junit.jupiter.api.Test; -import parser.generated.SimpleJavaLexer; - -import java.util.Arrays; -import java.util.List; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -public class ScannerTest { - - /** - * This test method is used to test the scanner functionality of the SimpleJavaLexer. - * It creates a CharStream from a string representing a simple Java class declaration, - * and uses the SimpleJavaLexer to tokenize this input. - * It then compares the actual tokens and their types produced by the lexer to the expected tokens and their types. - */ - @Test - public void scannerTest() { - // Create a CharStream from a string representing a simple Java class declaration - CharStream inputCharStream = CharStreams.fromString("public class Name {}"); - - // Use the SimpleJavaLexer to tokenize the input - SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream); - CommonTokenStream tokenStream = new CommonTokenStream(lexer); - tokenStream.fill(); - - // Prepare the expected results - List expectedTokens = Arrays.asList("public", "class", "Name", "{", "}", ""); - List expectedTokenTypes = Arrays.asList("AccessModifier", "Class", "Identifier", "OpenCurlyBracket", "ClosedCurlyBracket", "EOF"); - List actualTokens = tokenStream.getTokens(); - - // Compare the actual tokens and their types to the expected tokens and their types - assertEquals(expectedTokens.size(), actualTokens.size()); - for (int i = 0; i < expectedTokens.size(); i++) { - assertEquals(expectedTokens.get(i), actualTokens.get(i).getText()); - assertEquals(expectedTokenTypes.get(i), SimpleJavaLexer.VOCABULARY.getSymbolicName(actualTokens.get(i).getType())); - } - } -} diff --git a/src/test/java/semantic/BeginnToTAST.java b/src/test/java/semantic/BeginnToTAST.java deleted file mode 100644 index 8b59666..0000000 --- a/src/test/java/semantic/BeginnToTAST.java +++ /dev/null @@ -1,45 +0,0 @@ -package semantic; - -import ast.ProgramNode; -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.CharStreams; -import org.antlr.v4.runtime.CommonTokenStream; -import org.antlr.v4.runtime.tree.ParseTree; -import org.junit.jupiter.api.Test; -import parser.astBuilder.ASTBuilder; -import parser.generated.SimpleJavaLexer; -import parser.generated.SimpleJavaParser; - -import java.io.IOException; -import java.nio.file.Paths; - -import static org.junit.jupiter.api.Assertions.assertTrue; - -public class BeginnToTAST { - - @Test - public void FieldTests() { - SemanticAnalyzer.clearAnalyzer(); - - CharStream codeCharStream = null; - try { - codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/johnsTests/FieldTests.java")); - } catch (IOException e) { - throw new RuntimeException(e); - } - SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream); - CommonTokenStream tokenStream = new CommonTokenStream(lexer); - - SimpleJavaParser parser = new SimpleJavaParser(tokenStream); - ParseTree parseTree = parser.program(); // parse the input - - /* ------------------------- AST builder -> AST ------------------------- */ - ASTBuilder astBuilder = new ASTBuilder(); - ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree); - - var result = SemanticAnalyzer.generateTast(abstractSyntaxTree); - - assertTrue(SemanticAnalyzer.errors.isEmpty()); - } - -} diff --git a/src/test/java/semantic/SemanticHelper.java b/src/test/java/semantic/SemanticHelper.java index 7b0c0ed..1293e1d 100644 --- a/src/test/java/semantic/SemanticHelper.java +++ b/src/test/java/semantic/SemanticHelper.java @@ -27,6 +27,6 @@ public class SemanticHelper { ParseTree parseTree = parser.program(); ASTBuilder astBuilder = new ASTBuilder(); - return (ProgramNode) astBuilder.visit(parseTree); + return astBuilder.visit(parseTree); } } diff --git a/src/test/java/semantic/SemanticTest.java b/src/test/java/semantic/SemanticTest.java deleted file mode 100644 index f406580..0000000 --- a/src/test/java/semantic/SemanticTest.java +++ /dev/null @@ -1,5 +0,0 @@ -package semantic; - -public class SemanticTest { - -} \ No newline at end of file diff --git a/src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt$Car.class b/src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt$Car.class deleted file mode 100644 index 13e9f243d07c49179bc329ab3bc25b40a5312f99..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 448 zcmZut%TB^j5IxgU3bjgAL@;q-;sRL62WVW_gh+yDf?|Gu(`o&&XhJn6C7MyHPG^Y};{>8xrM!Gjp3} z#>FwAx{XQjdr87Nj8&GgY_r7&&cv`Kry@bIESV*_gI$SxQk||}0H^&4dS4SOf<1!a3eH;k>t8#+V{($=?i5x(1qY7Z-P$~;m9Iaywb%~y^N~oa$`U82FSONe5 diff --git a/src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt.class b/src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt.class deleted file mode 100644 index 4fee59341e764ff0ae786b9ad56c3223cc8e5682..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 461 zcmZ`#!A`IN#DcdsT3o~DGtxgYxJ1;IQ% zxhcX%(SqZm1eZ|vR1gd~y^ChOI9h7Uy;zK?BD4nUnn#|B&m5Fdu~2ofi5j8tpO9eB zIUPSR&$97-A#VLRN&BHpA%QtBnlYg=@IxN0mJ^Pz)g%xmpZvI-akPr3-19ZrTsP=c zuS_V7I7x@BpGXL9KMXnc0+l2z(3D@}P