i22005/NichtHaskell2.0
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixes and changed For Builder

Browse Source
This commit is contained in:
entep01 2024-07-04 16:30:19 +02:00
parent 91552ad147
commit 4775c3f47e
66 changed files with 336 additions and 574 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
README.md Normal file
View File

@ -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.

14
src/main/java/ast/ASTNode.java
View File

@ -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);
*/
}

9
src/main/java/ast/ClassNode.java
View File

@ -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<MemberNode> 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<MethodNode> getMethods(){
public List<MethodNode> getMethods() {
List<MethodNode> methods = new ArrayList<>();
for (MemberNode member : members) {
if (member instanceof MethodNode methodNode) {

2
src/main/java/ast/ProgramNode.java
View File

@ -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;

4
src/main/java/ast/expressions/binaryexpressions/BinaryNode.java
View File

@ -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) {

12
src/main/java/ast/expressions/binaryexpressions/CalculationNode.java
View File

@ -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;
}
}

24
src/main/java/ast/expressions/binaryexpressions/DotNode.java
View File

@ -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;
}
}

89
src/main/java/ast/expressions/binaryexpressions/DotSubstractionNode.java → src/main/java/ast/expressions/binaryexpressions/DotSubtractionNode.java
View File

@ -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);
}
}

30
src/main/java/ast/expressions/binaryexpressions/NonCalculationNode.java
View File

@ -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;
}
}

14
src/main/java/ast/expressions/unaryexpressions/MemberAccessNode.java
View File

@ -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<String> 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;
}
}

18
src/main/java/ast/expressions/unaryexpressions/NotNode.java
View File

@ -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);
}
}

6
src/main/java/ast/expressions/unaryexpressions/UnaryNode.java
View File

@ -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;

11
src/main/java/ast/literal/BooleanLiteralNode.java
View File

@ -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;
}
}

11
src/main/java/ast/literal/CharLiteralNode.java
View File

@ -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;
}
}

31
src/main/java/ast/literal/LiteralNode.java
View File

@ -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;
}
}

3
src/main/java/ast/members/ConstructorNode.java
View File

@ -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;
}

5
src/main/java/ast/members/FieldNode.java
View File

@ -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;

5
src/main/java/ast/members/MemberNode.java
View File

@ -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 {
}

10
src/main/java/ast/members/MethodNode.java
View File

@ -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<ParameterNode> 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;

2
src/main/java/ast/parameters/ParameterNode.java
View File

@ -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 {

2
src/main/java/ast/statementexpressions/AssignNode.java
View File

@ -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;

8
src/main/java/ast/statementexpressions/AssignableNode.java
View File

@ -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;
}

3
src/main/java/ast/statementexpressions/IStatementExpressionNode.java
View File

@ -2,4 +2,5 @@ package ast.statementexpressions;
import ast.statements.IStatementNode;
public interface IStatementExpressionNode extends IStatementNode {}
public interface IStatementExpressionNode extends IStatementNode {
}

2
src/main/java/ast/statementexpressions/NewDeclarationNode.java
View File

@ -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;

4
src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java
View File

@ -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;

3
src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java
View File

@ -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;

2
src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java
View File

@ -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;

2
src/main/java/ast/statementexpressions/methodcallstatementnexpressions/MethodCallNode.java
View File

@ -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;

3
src/main/java/ast/statementexpressions/methodcallstatementnexpressions/TargetNode.java
View File

@ -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 {

6
src/main/java/ast/statements/BlockNode.java
View File

@ -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<IStatementNode> statements = new ArrayList<>();
public BlockNode() {}
public BlockNode() {
}
public void addStatement(IStatementNode statement) {
statements.add(statement);

10
src/main/java/ast/statements/BlockStatementNode.java
View File

@ -1,10 +0,0 @@
package ast.statements;
import java.util.List;
public class BlockStatementNode {
List<IStatementNode> statements;
public BlockStatementNode(List<IStatementNode> statements) {this.statements = statements;}
}

2
src/main/java/ast/statements/ElseNode.java
View File

@ -1,7 +1,7 @@
package ast.statements;
import semantic.SemanticVisitor;
import typechecker.TypeCheckResult;
import semantic.TypeCheckResult;
public class ElseNode implements IStatementNode {
public BlockNode block;

2
src/main/java/ast/statements/IfElseNode.java
View File

@ -1,7 +1,7 @@
package ast.statements;
import semantic.SemanticVisitor;
import typechecker.TypeCheckResult;
import semantic.TypeCheckResult;
import java.util.ArrayList;
import java.util.List;

2
src/main/java/ast/statements/IfNode.java
View File

@ -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;

2
src/main/java/ast/statements/LocalVariableDeclarationNode.java
View File

@ -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;

4
src/main/java/ast/statements/ReturnNode.java
View File

@ -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;

3
src/main/java/ast/statements/WhileNode.java
View File

@ -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;
}

2
src/main/java/ast/type/AccessModifierNode.java
View File

@ -8,7 +8,7 @@ public class AccessModifierNode {
}
private void setModifier(String accessType) {
switch(accessType) {
switch (accessType) {
case "public":
this.accessType = EnumAccessModifierNode.PUBLIC;
break;

2
src/main/java/ast/type/ValueNode.java
View File

@ -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 {

6
src/main/java/ast/type/type/BaseType.java
View File

@ -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;
}
}

1
src/main/java/ast/type/type/ITypeNode.java
View File

@ -1,5 +1,4 @@
package ast.type.type;
public interface ITypeNode {
}

11
src/main/java/ast/type/type/ReferenceType.java
View File

@ -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);
}

3
src/main/java/ast/type/type/TypeEnum.java
View File

@ -4,6 +4,5 @@ public enum TypeEnum {
VOID,
INT,
CHAR,
BOOL;
BOOL
}

6
src/main/java/bytecode/ByteCodeGenerator.java
View File

@ -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;

10
src/main/java/bytecode/ClassCodeGen.java
View File

@ -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();

39
src/main/java/bytecode/MethodCodeGen.java
View File

@ -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<String> localVariables;
private final List<String> 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);

18
src/main/java/bytecode/visitor/MethodVisitor.java
View File

@ -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

2
src/main/java/bytecode/visitor/ProgramVisitor.java
View File

@ -3,5 +3,5 @@ package bytecode.visitor;
import ast.ProgramNode;
public interface ProgramVisitor {
void visit(ProgramNode programNode);
void visit(ProgramNode programNode);
}

22
src/main/java/parser/astBuilder/ASTBuilder.java
View File

@ -211,8 +211,8 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
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<ASTNode> {
// 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<ASTNode> {
// 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<ASTNode> {
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<ASTNode> {
@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<ASTNode> {
@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;
}

2
src/main/java/semantic/Scope.java
View File

@ -8,7 +8,7 @@ import java.util.Stack;
public class Scope {
private Stack<HashMap<String, ITypeNode>> localVars;
private final Stack<HashMap<String, ITypeNode>> localVars;
public Scope() {
localVars = new Stack<HashMap<String, ITypeNode>>();

12
src/main/java/semantic/SemanticAnalyzer.java
View File

@ -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<String, ITypeNode> currentFields = new HashMap<>();
private static final HashMap<String, ITypeNode> currentFields = new HashMap<>();
public static ArrayList<Exception> 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) {

3
src/main/java/semantic/SemanticVisitor.java
View File

@ -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);

44
src/main/java/typechecker/TypeCheckResult.java → src/main/java/semantic/TypeCheckResult.java
View File

@ -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;
}
}

4
src/main/java/semantic/context/ClassContext.java
View File

@ -9,8 +9,8 @@ import java.util.HashMap;
public class ClassContext {
private HashMap<String, FieldContext> fields;
private ArrayList<MethodNode> methods = new ArrayList<>();
private final HashMap<String, FieldContext> fields;
private final ArrayList<MethodNode> methods = new ArrayList<>();
public ClassContext(ClassNode classNode) {

2
src/main/java/semantic/context/Context.java
View File

@ -5,7 +5,7 @@ import java.util.HashMap;
public class Context {
private HashMap<String, ClassContext> classes;
private final HashMap<String, ClassContext> classes;
public Context(ProgramNode programNode) {
classes = new HashMap<>();

4
src/main/java/semantic/context/FieldContext.java
View File

@ -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;

2
src/main/java/visitor/Visitable.java
View File

@ -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) {

12
src/test/java/parser/AstBuilderTest.java
View File

@ -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"));

4
src/test/java/parser/Helper.java
View File

@ -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;

138
src/test/java/parser/ParserTest.java
View File

@ -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<String, Object> expectedTreeStructure = parseStringToTree(expectedParseTreeAsString);
Map<String, Object> actualTreeStructure = buildTreeStructure(parseTree, parser);
// assertEquals(expectedTreeStructure, actualTreeStructure);
}
// Helpers Variante 2.1
public static Map<String, Object> buildTreeStructure(ParseTree tree, Parser parser) {
return buildTree(tree, parser, 0);
}
private static Map<String, Object> buildTree(ParseTree tree, Parser parser, int indent) {
Map<String, Object> 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<Map<String, Object>> 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<String, Object> 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<String, Object> parse(String input) {
Map<String, Object> node = new HashMap<>();
StringBuilder currentToken = new StringBuilder();
List<Map<String, Object>> 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;
}
}

45
src/test/java/parser/ScannerTest.java
View File

@ -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<String> expectedTokens = Arrays.asList("public", "class", "Name", "{", "}", "<EOF>");
List<String> expectedTokenTypes = Arrays.asList("AccessModifier", "Class", "Identifier", "OpenCurlyBracket", "ClosedCurlyBracket", "EOF");
List<Token> 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()));
}
}
}

45
src/test/java/semantic/BeginnToTAST.java
View File

@ -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());
}
}

2
src/test/java/semantic/SemanticHelper.java
View File

@ -27,6 +27,6 @@ public class SemanticHelper {
ParseTree parseTree = parser.program();
ASTBuilder astBuilder = new ASTBuilder();
return (ProgramNode) astBuilder.visit(parseTree);
return astBuilder.visit(parseTree);
}
}

5
src/test/java/semantic/SemanticTest.java
View File

@ -1,5 +0,0 @@
package semantic;
public class SemanticTest {
}

BIN
src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt$Car.class
View File

Binary file not shown.

BIN
src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt.class
View File

Binary file not shown.