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

More Tests, Structure, etc. Huge Changes #14

Merged
i22005 merged 8 commits from Tests into main 2024-06-27 10:49:35 +00:00
Conversation 0 Commits 8 Files Changed 49 +602 -548
49 changed files with 602 additions and 548 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -83,3 +83,4 @@ src/test/resources/output/javac/CompilerInput$Test.class
src/test/resources/output/javac/CompilerInput.class
src/test/resources/output/raupenpiler/CompilerInput.class
src/test/resources/output/raupenpiler/CompilerInput$Test.class
.idea/inspectionProfiles/Project_Default.xml

6
src/main/java/main/Main.java
View File

@ -20,13 +20,11 @@ import java.nio.file.Paths;
* <p> <code> cd .\src\test\ </code>
* <p> <code> make clean compile-raupenpiler </code>
* <p> Start Raupenpiler using jar:
* <p> <code> java.exe -jar path_to_jar\JavaCompiler-1.0-SNAPSHOT-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
* <p> <code> java.exe -jar path_to_jar\JavaCompiler-1.0-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
* <p> Example (jar needs to be in the target directory, compile with make or mvn package first):
* <code> java.exe -jar .\target\JavaCompiler-1.0-SNAPSHOT-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
* <code> java.exe -jar .\target\JavaCompiler-1.0-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
*/
public class Main {
public static void main(String[] args) throws Exception {
if (args.length == 2) {
// args[0] is the input file path

30
src/main/java/main/RaupenLogger.java
View File

@ -16,18 +16,18 @@ import java.util.List;
import java.util.logging.*;
/**
Beispiel für Logging-Arten:
<p><code>logger.severe("Schwerwiegender Fehler");</code>
<p><code>logger.warning("Warnung");</code>
<p><code>logger.info("Information");</code>
<p><code>logger.config("Konfigurationshinweis");</code>
<p><code>logger.fine("Fein");</code>
<p><code>logger.finer("Feiner");</code>
<p><code>logger.finest("Am feinsten");</code>
<p>You may toggle the logging level of the console and file handlers by
changing the level ALL/OFF/etc. in the constructor.
<code>consoleHandler.setLevel(Level.OFF);</code>
<code>fileHandler.setLevel(Level.ALL);</code>
* Beispiel für Logging-Arten:
* <p><code>logger.severe("Schwerwiegender Fehler");</code>
* <p><code>logger.warning("Warnung");</code>
* <p><code>logger.info("Information");</code>
* <p><code>logger.config("Konfigurationshinweis");</code>
* <p><code>logger.fine("Fein");</code>
* <p><code>logger.finer("Feiner");</code>
* <p><code>logger.finest("Am feinsten");</code>
* <p>You may toggle the logging level of the console and file handlers by
* changing the level ALL/OFF/etc. in the constructor.
* <code>consoleHandler.setLevel(Level.OFF);</code>
* <code>fileHandler.setLevel(Level.ALL);</code>
*/
public class RaupenLogger {
@ -172,9 +172,9 @@ public class RaupenLogger {
}
String indentString = " ".repeat(indent * 2);
logger.info(indentString + abstractSyntaxTree.getClass());
//for (ASTNode child : abstractSyntaxTree.getChildren()) {
// logAST(child, indent + 1);
// }
// for (ASTNode child : node.) {
// printAST(child, indent + 1);
// }
}
}

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

@ -53,7 +53,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitConstructorDeclaration(SimpleJavaParser.ConstructorDeclarationContext ctx) {
ConstructorNode constructorNode = new ConstructorNode(ctx.AccessModifier().getText(), ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
for (SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
constructorNode.addParameter((ParameterNode) visit(parameter));
}
return constructorNode;
@ -61,18 +61,18 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitMethodDeclaration(SimpleJavaParser.MethodDeclarationContext ctx) {
if(ctx.MainMethodDeclaration() != null) {
if (ctx.MainMethodDeclaration() != null) {
return new MainMethodNode((BlockNode) visit(ctx.block()));
} else {
if(ctx.type() != null) {
if (ctx.type() != null) {
MethodNode methodNode = new MethodNode(ctx.AccessModifier().getText(), createTypeNode(ctx.type().getText()), false, ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
for (SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
methodNode.addParameter((ParameterNode) visit(parameter));
}
return methodNode;
} else {
MethodNode methodNode = new MethodNode(ctx.AccessModifier().getText(), null, true, ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
for (SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
methodNode.addParameter((ParameterNode) visit(parameter));
}
return methodNode;
@ -92,19 +92,19 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitStatement(SimpleJavaParser.StatementContext ctx) {
if(ctx.returnStatement() != null) {
if (ctx.returnStatement() != null) {
return visitReturnStatement(ctx.returnStatement());
} else if(ctx.localVariableDeclaration() != null) {
} else if (ctx.localVariableDeclaration() != null) {
return visitLocalVariableDeclaration(ctx.localVariableDeclaration());
} else if(ctx.block() != null) {
} else if (ctx.block() != null) {
return visitBlock(ctx.block());
} else if(ctx.whileStatement() != null) {
} else if (ctx.whileStatement() != null) {
return visitWhileStatement(ctx.whileStatement());
} else if(ctx.forStatement() != null) {
} else if (ctx.forStatement() != null) {
return visitForStatement(ctx.forStatement());
} else if(ctx.ifElseStatement() != null) {
} else if (ctx.ifElseStatement() != null) {
return visitIfElseStatement(ctx.ifElseStatement());
} else if(ctx.statementExpression() != null) {
} else if (ctx.statementExpression() != null) {
return visitStatementExpression(ctx.statementExpression());
}
return null;
@ -123,10 +123,10 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitBlock(SimpleJavaParser.BlockContext ctx) {
BlockNode blockNode = new BlockNode();
for(SimpleJavaParser.StatementContext statement : ctx.statement()) {
for (SimpleJavaParser.StatementContext statement : ctx.statement()) {
blockNode.addStatement((IStatementNode) visit(statement));
}
if(!blockNode.hasReturnStatement) {
if (!blockNode.hasReturnStatement) {
blockNode.addStatement(new ReturnStatementNode(null));
}
return blockNode;
@ -139,9 +139,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitForStatement(SimpleJavaParser.ForStatementContext ctx) {
if(ctx.statementExpression(0) != null) {
if (ctx.statementExpression(0) != null) {
return new ForStatementNode((IExpressionNode) visit(ctx.statementExpression(0)), (IExpressionNode) visit(ctx.expression()), (IExpressionNode) visit(ctx.statementExpression(1)));
} else if(ctx.localVariableDeclaration() != null) {
} else if (ctx.localVariableDeclaration() != null) {
return new ForStatementNode((IStatementNode) visit(ctx.localVariableDeclaration()), (IExpressionNode) visit(ctx.expression()), (IExpressionNode) visit(ctx.statementExpression(1)));
}
return null;
@ -149,8 +149,8 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitIfElseStatement(SimpleJavaParser.IfElseStatementContext ctx) {
IfElseStatementNode ifElseStatementNode = new IfElseStatementNode((IfStatementNode) visit(ctx.ifStatement()));
for(SimpleJavaParser.ElseStatementContext elseStatement : ctx.elseStatement()) {
IfElseStatementNode ifElseStatementNode = new IfElseStatementNode((IfStatementNode) visit(ctx.ifStatement()));
for (SimpleJavaParser.ElseStatementContext elseStatement : ctx.elseStatement()) {
ifElseStatementNode.addElseStatement((ElseStatementNode) visit(elseStatement));
}
return ifElseStatementNode;
@ -168,13 +168,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitStatementExpression(SimpleJavaParser.StatementExpressionContext ctx) {
if(ctx.assign() != null) {
if (ctx.assign() != null) {
return visitAssign(ctx.assign());
} else if(ctx.newDeclaration() != null) {
} else if (ctx.newDeclaration() != null) {
return visitNewDeclaration(ctx.newDeclaration());
} else if(ctx.methodCall() != null) {
} else if (ctx.methodCall() != null) {
return visitMethodCall(ctx.methodCall());
} else if(ctx.crementExpression() != null) {
} else if (ctx.crementExpression() != null) {
return visitCrementExpression(ctx.crementExpression());
}
return null;
@ -188,7 +188,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitNewDeclaration(SimpleJavaParser.NewDeclarationContext ctx) {
NewDeclarationStatementExpressionNode newDeclarationStatementExpressionNode = new NewDeclarationStatementExpressionNode(ctx.Identifier().getText());
for(SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
for (SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
newDeclarationStatementExpressionNode.addExpression((IExpressionNode) visit(expression));
}
return newDeclarationStatementExpressionNode;
@ -197,10 +197,10 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitMethodCall(SimpleJavaParser.MethodCallContext ctx) {
MethodCallStatementExpressionNode methodCallStatementExpressionNode = new MethodCallStatementExpressionNode((TargetNode) visit(ctx.target()), ctx.Identifier().getText());
for(SimpleJavaParser.ChainedMethodContext chainedMethod : ctx.chainedMethod()) {
for (SimpleJavaParser.ChainedMethodContext chainedMethod : ctx.chainedMethod()) {
methodCallStatementExpressionNode.addChainedMethod((ChainedMethodNode) visit(chainedMethod));
}
for(SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
for (SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
methodCallStatementExpressionNode.addExpression((IExpressionNode) visit(expression));
}
return methodCallStatementExpressionNode;
@ -208,13 +208,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitTarget(SimpleJavaParser.TargetContext ctx) {
if(ctx.This() != null) {
if (ctx.This() != null) {
return new TargetNode(true);
} else if(ctx.memberAccess() != null) {
} else if (ctx.memberAccess() != null) {
return new TargetNode((MemberAccessNode) visit(ctx.memberAccess()));
} else if(ctx.newDeclaration() != null) {
} else if (ctx.newDeclaration() != null) {
return new TargetNode((NewDeclarationStatementExpressionNode) visit(ctx.newDeclaration()));
} else if(ctx.Identifier() != null) {
} else if (ctx.Identifier() != null) {
return new TargetNode(ctx.Identifier().getText());
}
return null;
@ -223,7 +223,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitChainedMethod(SimpleJavaParser.ChainedMethodContext ctx) {
ChainedMethodNode chainedMethodNode = new ChainedMethodNode(ctx.Identifier().getText());
for(SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
for (SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
chainedMethodNode.addExpression((IExpressionNode) visit(expression));
}
return chainedMethodNode;
@ -231,9 +231,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitCrementExpression(SimpleJavaParser.CrementExpressionContext ctx) {
if(ctx.incrementExpression() != null) {
if (ctx.incrementExpression() != null) {
return visitIncrementExpression(ctx.incrementExpression());
} else if(ctx.decrementExpression() != null) {
} else if (ctx.decrementExpression() != null) {
return visitDecrementExpression(ctx.decrementExpression());
}
return null;
@ -241,9 +241,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitIncrementExpression(SimpleJavaParser.IncrementExpressionContext ctx) {
if(ctx.prefixIncrementExpression() != null) {
if (ctx.prefixIncrementExpression() != null) {
return visitPrefixIncrementExpression(ctx.prefixIncrementExpression());
} else if(ctx.suffixIncrementExpression() != null) {
} else if (ctx.suffixIncrementExpression() != null) {
return visitSuffixIncrementExpression(ctx.suffixIncrementExpression());
}
return null;
@ -261,9 +261,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitDecrementExpression(SimpleJavaParser.DecrementExpressionContext ctx) {
if(ctx.prefixDecrementExpression() != null) {
if (ctx.prefixDecrementExpression() != null) {
return visitPrefixDecrementExpression(ctx.prefixDecrementExpression());
} else if(ctx.suffixDecrementExpression() != null) {
} else if (ctx.suffixDecrementExpression() != null) {
return visitSuffixDecrementExpression(ctx.suffixDecrementExpression());
}
return null;
@ -281,9 +281,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitExpression(SimpleJavaParser.ExpressionContext ctx) {
if(ctx.unaryExpression() != null) {
if (ctx.unaryExpression() != null) {
return visit(ctx.unaryExpression());
} else if(ctx.binaryExpression() != null) {
} else if (ctx.binaryExpression() != null) {
return visit(ctx.binaryExpression());
}
return null;
@ -291,19 +291,19 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitUnaryExpression(SimpleJavaParser.UnaryExpressionContext ctx) {
if(ctx.This() != null) {
if (ctx.This() != null) {
return new UnaryExpressionNode(ctx.This().getText());
} else if(ctx.Identifier() != null) {
} else if (ctx.Identifier() != null) {
return new UnaryExpressionNode(ctx.Identifier().getText());
} else if(ctx.memberAccess() != null) {
} else if (ctx.memberAccess() != null) {
return new UnaryExpressionNode((MemberAccessNode) visitMemberAccess(ctx.memberAccess()));
} else if(ctx.value() != null) {
} else if (ctx.value() != null) {
return new UnaryExpressionNode((ValueNode) visitValue(ctx.value()));
} else if(ctx.notExpression() != null) {
} else if (ctx.notExpression() != null) {
return new UnaryExpressionNode((NotExpressionNode) visitNotExpression(ctx.notExpression()));
} else if(ctx.statementExpression() != null) {
} else if (ctx.statementExpression() != null) {
return new UnaryExpressionNode((IStatementNode) visitStatementExpression(ctx.statementExpression()));
} else if(ctx.expression() != null) {
} else if (ctx.expression() != null) {
return new UnaryExpressionNode((IExpressionNode) visitExpression(ctx.expression()));
}
return null;
@ -312,7 +312,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitMemberAccess(SimpleJavaParser.MemberAccessContext ctx) {
MemberAccessNode memberAccessNode;
if(ctx.This() != null) {
if (ctx.This() != null) {
memberAccessNode = new MemberAccessNode(true);
} else {
memberAccessNode = new MemberAccessNode(false);
@ -325,13 +325,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitValue(SimpleJavaParser.ValueContext ctx) {
if(ctx.IntValue() != null) {
if (ctx.IntValue() != null) {
return new ValueNode(EnumValueNode.INT_VALUE, ctx.IntValue().getText());
} else if(ctx.BooleanValue() != null) {
} else if (ctx.BooleanValue() != null) {
return new ValueNode(EnumValueNode.BOOLEAN_VALUE, ctx.BooleanValue().getText());
} else if(ctx.CharValue() != null) {
} else if (ctx.CharValue() != null) {
return new ValueNode(EnumValueNode.CHAR_VALUE, ctx.CharValue().getText());
} else if(ctx.NullValue() != null) {
} else if (ctx.NullValue() != null) {
return new ValueNode(EnumValueNode.NULL_VALUE, ctx.NullValue().getText());
}
return null;
@ -345,9 +345,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitBinaryExpression(SimpleJavaParser.BinaryExpressionContext ctx) {
if(ctx.calculationExpression() != null) {
if (ctx.calculationExpression() != null) {
return visit(ctx.calculationExpression());
} else if(ctx.nonCalculationExpression() != null) {
} else if (ctx.nonCalculationExpression() != null) {
return visit(ctx.nonCalculationExpression());
}
return null;
@ -355,9 +355,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitCalculationExpression(SimpleJavaParser.CalculationExpressionContext ctx) {
if(ctx.calculationExpression() != null) {
if (ctx.calculationExpression() != null) {
return new CalculationExpressionNode((CalculationExpressionNode) visit(ctx.calculationExpression()), ctx.LineOperator().getText(), (DotExpressionNode) visit(ctx.dotExpression()));
} else if(ctx.dotExpression() != null) {
} else if (ctx.dotExpression() != null) {
return new CalculationExpressionNode((DotExpressionNode) visit(ctx.dotExpression()));
}
return null;
@ -365,9 +365,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitDotExpression(SimpleJavaParser.DotExpressionContext ctx) {
if(ctx.dotExpression() != null) {
if (ctx.dotExpression() != null) {
return new DotExpressionNode((DotExpressionNode) visit(ctx.dotExpression()), ctx.DotOperator().getText(), (DotSubstractionExpressionNode) visit(ctx.dotSubtractionExpression()));
} else if(ctx.dotSubtractionExpression() != null) {
} else if (ctx.dotSubtractionExpression() != null) {
return new DotExpressionNode((DotSubstractionExpressionNode) visit(ctx.dotSubtractionExpression()));
}
return null;
@ -375,13 +375,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitDotSubtractionExpression(SimpleJavaParser.DotSubtractionExpressionContext ctx) {
if(ctx.IntValue() != null) {
if (ctx.IntValue() != null) {
return new DotSubstractionExpressionNode(new ValueNode(EnumValueNode.INT_VALUE, ctx.IntValue().getText()));
} else if(ctx.Identifier() != null) {
} else if (ctx.Identifier() != null) {
return new DotSubstractionExpressionNode(ctx.Identifier().getText());
} else if(ctx.memberAccess() != null) {
} else if (ctx.memberAccess() != null) {
return new DotSubstractionExpressionNode((MemberAccessNode) visit(ctx.memberAccess()));
} else if(ctx.methodCall() != null && ctx.calculationExpression() != null) {
} else if (ctx.methodCall() != null && ctx.calculationExpression() != null) {
return new DotSubstractionExpressionNode((MethodCallStatementExpressionNode) visit(ctx.methodCall()), (CalculationExpressionNode) visit(ctx.calculationExpression()));
}
return null;
@ -394,15 +394,15 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitAssignableExpression(SimpleJavaParser.AssignableExpressionContext ctx) {
if(ctx.Identifier() != null) {
if (ctx.Identifier() != null) {
return new AssignableExpressionNode(ctx.Identifier().getText());
} else if(ctx.memberAccess() != null) {
} else if (ctx.memberAccess() != null) {
return new AssignableExpressionNode((MemberAccessNode) visit(ctx.memberAccess()));
}
return null;
}
public ITypeNode createTypeNode(String identifier){
public ITypeNode createTypeNode(String identifier) {
return switch (identifier) {
case "int" -> new BaseType(TypeEnum.INT);
case "boolean" -> new BaseType(TypeEnum.BOOL);

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

@ -1,7 +1,7 @@
package semantic;
import ast.type.type.*;
import semantic.exeptions.AlreadyDeclearedException;
import semantic.exceptions.AlreadyDeclaredException;
import java.util.HashMap;
import java.util.Stack;
@ -16,7 +16,7 @@ public class Scope {
public void addLocalVar(String name, ITypeNode type) {
if (this.contains(name)) {
throw new AlreadyDeclearedException("Variable " + name + " already exists in this scope");
throw new AlreadyDeclaredException("Variable " + name + " already exists in this scope");
}
localVars.peek().put(name, type);
}

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

@ -25,7 +25,7 @@ import ast.statement.statementexpression.crementExpression.IncrementExpressionNo
import ast.statement.statementexpression.methodcallstatementnexpression.MethodCallStatementExpressionNode;
import ast.type.type.*;
import semantic.context.Context;
import semantic.exeptions.*;
import semantic.exceptions.*;
import typechecker.TypeCheckResult;
public class SemanticAnalyzer implements SemanticVisitor {
@ -117,7 +117,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
if (Objects.equals(otherMethod, methodNode))
break;
if (otherMethod.isSame(methodNode)) {
errors.add(new AlreadyDeclearedException(
errors.add(new AlreadyDeclaredException(
"Method " + methodNode.getIdentifier() + " is already defined in class "
+ currentClass.identifier));
valid = false;
@ -130,8 +130,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
valid = valid && result.isValid();
try {
currentScope.addLocalVar(parameter.identifier, parameter.type);
} catch (AlreadyDeclearedException e) {
errors.add(new AlreadyDeclearedException(parameter.identifier));
} catch (AlreadyDeclaredException e) {
errors.add(new AlreadyDeclaredException(parameter.identifier));
}
}
@ -165,7 +165,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
@Override
public TypeCheckResult analyze(FieldNode toCheck) {
if (currentFields.get(toCheck.identifier) != null) {
errors.add(new AlreadyDeclearedException("Already declared " + toCheck.identifier));
errors.add(new AlreadyDeclaredException("Already declared " + toCheck.identifier));
return new TypeCheckResult(false, null);
} else {
currentFields.put(toCheck.identifier, toCheck.type);
@ -362,7 +362,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
} else if(currentFields.get(unary.identifier) != null) {
return new TypeCheckResult(valid, currentFields.get(unary.identifier));
} else {
errors.add(new NotDeclearedException("Var is not Decleared"));
errors.add(new NotDeclaredException("Var is not Declared"));
}
return new TypeCheckResult(valid, null);
}

9
src/main/java/semantic/exceptions/AlreadyDeclaredException.java Normal file
View File

@ -0,0 +1,9 @@
package semantic.exceptions;
public class AlreadyDeclaredException extends RuntimeException {
public AlreadyDeclaredException(String message) {
super(message);
}
}

2
src/main/java/semantic/exeptions/AlreadyDefinedException.java → src/main/java/semantic/exceptions/AlreadyDefinedException.java
View File

@ -1,4 +1,4 @@
package semantic.exeptions;
package semantic.exceptions;
public class AlreadyDefinedException extends RuntimeException {

2
src/main/java/semantic/exeptions/MultipleReturnTypes.java → src/main/java/semantic/exceptions/MultipleReturnTypes.java
View File

@ -1,4 +1,4 @@
package semantic.exeptions;
package semantic.exceptions;
public class MultipleReturnTypes extends RuntimeException {

9
src/main/java/semantic/exceptions/NotDeclaredException.java Normal file
View File

@ -0,0 +1,9 @@
package semantic.exceptions;
public class NotDeclaredException extends RuntimeException {
public NotDeclaredException(String message) {
super(message);
}
}

2
src/main/java/semantic/exeptions/TypeMismatchException.java → src/main/java/semantic/exceptions/TypeMismatchException.java
View File

@ -1,4 +1,4 @@
package semantic.exeptions;
package semantic.exceptions;
public class TypeMismatchException extends RuntimeException {

9
src/main/java/semantic/exceptions/UnknownException.java Normal file
View File

@ -0,0 +1,9 @@
package semantic.exceptions;
public class UnknownException extends RuntimeException {
public UnknownException(String message) {
super(message);
}
}

9
src/main/java/semantic/exeptions/AlreadyDeclearedException.java
View File

@ -1,9 +0,0 @@
package semantic.exeptions;
public class AlreadyDeclearedException extends RuntimeException {
public AlreadyDeclearedException(String message) {
super(message);
}
}

9
src/main/java/semantic/exeptions/NotDeclearedException.java
View File

@ -1,9 +0,0 @@
package semantic.exeptions;
public class NotDeclearedException extends RuntimeException {
public NotDeclearedException(String message) {
super(message);
}
}

25
src/test/Makefile
View File

@ -10,20 +10,33 @@ compile-javac:
compile-raupenpiler:
cd ../.. ; mvn -DskipTests install
cd ../.. ; mvn exec:java -Dexec.mainClass="main.Main" -Dexec.args="'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' "
cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
test: test-javac test-raupenpiler
test: compile-javac compile-raupenpiler test-javac test-raupenpiler
test-javac:
#compile-javac
#java -cp .\resources\output\javac CompilerInput
# gleich wie bei raupenpiler, kann ich ohne funktionierenden Compiler nicht testen
test-raupenpiler:
#java -cp .\resources\output\raupenpiler CompilerInput
# move the compiled class to the test/main folder
mv ../main/resources/output/CompilerInput.class .java/main/
# compile the test class
javac .java/main.EndToEndTester.java
# run the test class
java .java/main.EndToEndTester
clean:
# clean output folders
rm -f ../main/resources/output/*.class
rm -f ./resources/output/javac/*.class
rm -f ./resources/output/raupenpiler/*.class
rm -f ./java/*.class
rm -f ../main/resources/output/*.class
# clean logs
rm -f ../main/resources/logs/*.log
# clean test/main folders from .class files for End-to-End tests
rm -f ./java/main/*.class
# clean javac output from featureTests
rm -f ./resources/input/featureTests/*.class

7
src/test/TestSpecs.md
View File

@ -78,8 +78,8 @@ Compiled Classfile
wenn beides erfolgreich
- Ergebnis vom eigenen Compiler mithilfe von main.TestCompilerOutput ausführen
- (Ergebnis von javac mithilfe von main.TestCompilerOutput ausführen)
- Ergebnis vom eigenen Compiler mithilfe von main.EndToEndTester ausführen
- (Ergebnis von javac mithilfe von main.EndToEndTester ausführen)
### Andis Tipps:
@ -89,4 +89,5 @@ wenn beides erfolgreich
- mvn package
- javac tester // tester compilen
- java tester // tester ausführen
- -> tester ist in unserem Fall main.TestCompilerOutput.java
- -> tester ist in unserem Fall main.EndToEndTester.java
- -> Hab ich alles umgesetzt

6
src/test/java/main/EmptyClassExample.java
View File

@ -1,6 +0,0 @@
package main;
public class EmptyClassExample {
private class Inner {
}
} // -o für outout

8
src/test/java/main/TestCompilerOutput.java → src/test/java/main/EndToEndTester.java
View File

@ -3,18 +3,18 @@ package main;
/**
* This class is used to test the output of the compiler.
*
* <p>Im gleichen Ordner wie diese Datei (main.TestCompilerOutput.java) muss die selbst kompilierte CompilerInput.class Datei sein.
* <br><strong>Hinweis:</strong> Diese muss man also vom Ordner <code> main/resources/output </code> in diesen Ordner hier (test/java) rein kopieren. (bis es eine bessere Lösung gibt)</p>
* <p>Im gleichen Ordner wie diese Datei (EndToEndTester.java) muss die selbst kompilierte CompilerInput.class Datei sein.
* <br><strong>Hinweis:</strong> Diese muss man also vom Ordner <code> main/resources/output </code> in diesen Ordner hier (test/java/main) rein kopieren. (bis es eine bessere Lösung gibt -> bin grad in der Make dran das alles hier automatisch zu machen)</p>
*
* <p>Die selbst kompilierte .class Datei wird dann hier drin geladen und eine Instanz von ihr erstellt, es können auch Methoden aufgerufen werden.
* <p>Diese main.TestCompilerOutput.java Datei wird dann in <code> \src\test\java> </code> mit <code>javac .\main.TestCompilerOutput.java</code> kompiliert und mit <code>java main.TestCompilerOutput</code> ausgeführt.
* <p>Diese EndToEndTester.java Datei wird dann in <code> \src\test\java> </code> mit <code>javac .\main.EndToEndTester.java</code> kompiliert und mit <code>java main.EndToEndTester</code> ausgeführt.
* Wenn unser Compiler funktioniert, sollten keine Errors kommen (sondern nur die Ausgaben, die wir in der CompilerInput.java Datei gemacht haben,
* oder Methoden, die wir hier aufrufen).</p>
*
* <p><strong>PROBLEM:</strong> Hier kommen Errors, was eigentlich heißt, dass der Compiler nicht funktioniert, der Test sollte eigentlich passen.
* <br><strong>DENN:</strong> Wenn ich statt unserem CompilerInput.class die CompilerInput.class von javac verwende (aus <code> src/test/resources/output/javac </code>), dann funktioniert es.</p>
*/
public class TestCompilerOutput {
public class EndToEndTester {
public static void main(String[] args) {
try {
// Try to load the class named "CompilerInput"

66
src/test/java/main/FailureTest.java
View File

@ -3,71 +3,45 @@ package main;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.junit.jupiter.api.Test;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
public class FailureTest {
private static final List<String> TEST_FILES = Arrays.asList(
"src/main/test/resources/input/failureTests/TestClass1.java",
"src/main/test/resources/input/failureTests/TestClass2.java",
"src/main/test/resources/input/failureTests/TestClass3.java",
"src/main/test/resources/input/failureTests/TestClass4.java",
"src/main/test/resources/input/failureTests/TestClass5.java",
"src/main/test/resources/input/failureTests/TestClass6.java",
"src/main/test/resources/input/failureTests/TestClass7.java",
"src/main/test/resources/input/failureTests/TestClass8.java",
"src/main/test/resources/input/failureTests/TestClass9.java",
"src/main/test/resources/input/failureTests/TestClass10.java",
"src/main/test/resources/input/failureTests/TestClass11.java"
);
/**
* This test method checks if invalid Java files fail to compile as expected.
* It uses the JavaCompiler from the ToolProvider to compile the files.
* The test passes if all the files fail to compile.
*/
@Test
public void invalidJavaFilesTest() {
public void areTestFilesActuallyFailTest() {
// Get the system Java compiler
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
// Assert that the compiler is available
assertNotNull(compiler, "Java Compiler is not available");
assertNotNull(javac, "Java Compiler is not available");
// Iterate over the test files
for (String fileName : TEST_FILES) {
// Create a File object for the current file
File file = new File(fileName);
String directoryPath = "src/test/resources/input/failureTests";
File folder = new File(directoryPath);
// Try to compile the file and get the result
// The run method returns 0 if the compilation was successful, and non-zero otherwise
int result = compiler.run(null, null, null, file.getPath());
if (folder.isDirectory()) {
File[] files = folder.listFiles((dir, name) -> name.endsWith(".java"));
// Assert that the compilation failed (i.e., the result is non-zero)
assertTrue(result != 0, "Expected compilation failure for " + fileName);
}
}
if (files != null) {
for (File file : files) {
// Try to compile the file and get the result
// The run method returns 0 if the compilation was successful, and non-zero otherwise
int result = javac.run(null, null, null, file.getPath());
// schmeißt John Fehler, wenn namen doppelt sind?
// Input: ParseTree mit genanntem Fehler
// Output: Fehlermeldung
@Test
void typedASTTest() throws IOException {
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/main/EmptyClassExample.java"));
Main.compileFile(codeCharStream, "src/main/test/resources/output");
} catch (IOException e) {
System.err.println("Error reading the file: " + e.getMessage());
// Assert that the compilation failed (i.e., the result is non-zero)
assertTrue(result != 0, "Expected compilation failure for " + file.getName());
}
} else {
System.out.println("No files found in the directory.");
}
} else {
System.out.println("The provided path is not a directory.");
}
}
}

46
src/test/java/main/FeatureTest.java Normal file
View File

@ -0,0 +1,46 @@
package main;
import org.junit.jupiter.api.Test;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.File;
import static org.junit.jupiter.api.Assertions.*;
public class FeatureTest {
/**
* This test method checks if valid Java files compile successfully.
* It uses the JavaCompiler from the ToolProvider to compile the files.
* The test passes if all the files compile without errors.
*/
@Test
public void areTestFilesActuallyValid() {
// Get the system Java compiler
JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
// Assert that the compiler is available
assertNotNull(javac, "Java Compiler is not available");
String directoryPath = "src/test/resources/input/featureTests";
File folder = new File(directoryPath);
if (folder.isDirectory()) {
File[] files = folder.listFiles((dir, name) -> name.endsWith(".java"));
if (files != null) {
for (File file : files) {
// Try to compile the file and get the result
// The run method returns 0 if the compilation was successful, and non-zero otherwise
int result = javac.run(null, null, null, file.getPath());
// Assert that the compilation succeeded (i.e., the result is zero)
assertEquals(0, result, "Expected compilation success for " + file.getName());
}
} else {
System.out.println("No files found in the directory.");
}
} else {
System.out.println("The provided path is not a directory.");
}
}
}

6
src/test/java/main/MainTest.java
View File

@ -7,14 +7,14 @@ import org.antlr.v4.runtime.CharStreams;
import java.io.IOException;
import java.nio.file.Paths;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* run: mvn test
* run every test: mvn test
* Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
*/
public class MainTest {
@Test
void testEmptyClass() {
void test() {
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/CompilerInput.java"));

103
src/test/java/parser/AstBuilderTest.java Normal file
View File

@ -0,0 +1,103 @@
package parser;
import ast.ClassNode;
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 static org.junit.jupiter.api.Assertions.assertEquals;
public class AstBuilderTest {
@Test
public void astBuilderTest() {
// ---------------- Leere Klasse nachgebaut ----------------
ProgramNode expectedASTEmptyClass = new ProgramNode();
// public class Name {}
ClassNode nameClass = new ClassNode("public", "Name");
expectedASTEmptyClass.addClass(nameClass);
// ---------------- Leere Klasse erzeugt ----------------
// 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 parseTreeEmptyClass = parser.program(); // parse the input
/* AST builder -> AST */
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode actualASTEmptyClass = (ProgramNode) new ASTBuilder().visit(parseTreeEmptyClass);
// ---------------- Vergleichen ----------------
String expectedASTasString = expectedASTEmptyClass.toString();
String actualASTasString = new ASTBuilder().visit(parseTreeEmptyClass).toString();
// Wie vergleiche ich das?
assertEquals(expectedASTasString, actualASTasString);
assertEquals(expectedASTEmptyClass, actualASTEmptyClass);
}
// ---------------- Alter CompilerInput nachgebaut ----------------
// ProgramNode startNode = new ProgramNode();
// public class CompilerInput {}
// ClassNode compilerInputClass = new ClassNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), "CompilerInput");
// public int a;
// compilerInputClass.addMember(new FieldNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), new BaseTypeNode(EnumTypeNode.INT), "a"));
// public static int testMethod(char x) { return 0; }
/* compilerInputClass.addMember(
new MethodNode(
new AccessTypeNode(EnumAccessTypeNode.PUBLIC),
new BaseTypeNode(EnumTypeNode.INT),
"testMethod",
new ParameterListNode(List.of(new ParameterNode(new BaseTypeNode(EnumTypeNode.CHAR), "x"))),
List.of(new ReturnStatementNode(new LiteralNode(0)))
));
ClassNode testClass = new ClassNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), "Test");
testClass.addMember(
new MethodNode(
new AccessTypeNode(EnumAccessTypeNode.PUBLIC),
new BaseTypeNode(EnumTypeNode.INT),
"testMethod",
new ParameterListNode(List.of(new ParameterNode(new BaseTypeNode(EnumTypeNode.CHAR), "x"), new ParameterNode(new BaseTypeNode(EnumTypeNode.INT), "a"))),
List.of(new ReturnStatementNode(new LiteralNode(0)))
)
);
*/
//compilerInputClass.addClass(testClass);
// startNode.addClass(compilerInputClass);
// startNode.addClass(testClass);
}

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

@ -4,7 +4,6 @@ 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.astBuilder.ASTBuilder;
import parser.generated.SimpleJavaLexer;
import parser.generated.SimpleJavaParser;
@ -13,41 +12,13 @@ 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";
}
/**
* 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<Token> actualTokens = tokenStream.getTokens();
List<String> expectedTokens = Arrays.asList("public", "class", "Name", "{", "}", "<EOF>");
List<String> expectedTokenTypes = Arrays.asList(null, null, "IDENTIFIER", null, null, "EOF");
// 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()));
}
}
@Test
public void parserTest() {
@ -63,38 +34,20 @@ public class ParserTest {
ParseTree parseTree = parser.program(); // parse the input
//Variante 1 (geht)
String expectedParseTreeAsString = "(program (classDeclaration public class Name { }))";
String actualParseTreeAsString = parseTree.toStringTree(parser);
String expectedParseTreeAsString = "(program (classDeclaration (accessType public) class Name { }))";
assertEquals(actualParseTreeAsString, expectedParseTreeAsString);
assertEquals(expectedParseTreeAsString, actualParseTreeAsString);
//Variante 2 (geht nicht)
// Variante 2 (geht nicht)
// - Sollte es gehen und es liegt am Parser? (keine Ahnung) -> Bitte Fehler (actual und expected) durchlesen
Map<String, Object> actualTreeStructure = buildTreeStructure(parseTree, parser);
// ist die Methode parseStringToTree() korrekt? -> (glaub nicht)
Map<String, Object> expectedTreeStructure = parseStringToTree(expectedParseTreeAsString);
Map<String, Object> actualTreeStructure = buildTreeStructure(parseTree, parser);
assertEquals(actualTreeStructure, expectedTreeStructure);
// assertEquals(expectedTreeStructure, actualTreeStructure);
}
@Test
public void astBuilderTest() {
// TODO: Implement this test method
/* AST builder -> AST */
ASTBuilder astBuilder = new ASTBuilder();
// ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
//String actualASTasString = new ASTBuilder().visit(parseTree).toString();
// ProgramNode actualAST = new ASTBuilder().visit(parseTree);
// ProgramNode expectedAST = new ProgramNode();
// expectedAST.add(new ProgramNode.ClassNode("Name", new ProgramNode()));
}
// Helpers Variante 2.1
@ -146,7 +99,7 @@ public class ParserTest {
for (char ch : input.toCharArray()) {
if (ch == '(') {
if (depth == 0) {
if (currentToken.length() > 0) {
if (!currentToken.isEmpty()) {
node.put("node", currentToken.toString().trim());
currentToken.setLength(0);
}
@ -163,7 +116,7 @@ public class ParserTest {
currentToken.append(ch);
}
} else if (Character.isWhitespace(ch) && depth == 0) {
if (currentToken.length() > 0) {
if (!currentToken.isEmpty()) {
node.put("node", currentToken.toString().trim());
currentToken.setLength(0);
}
@ -172,7 +125,7 @@ public class ParserTest {
}
}
if (currentToken.length() > 0) {
if (!currentToken.isEmpty()) {
node.put("node", currentToken.toString().trim());
}

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

@ -0,0 +1,45 @@
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()));
}
}
}

282
src/test/java/semantic/EndToTAST.java
View File

@ -1,282 +0,0 @@
package semantic;
import ast.ASTNode;
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.BeforeEach;
import org.junit.jupiter.api.Test;
import parser.astBuilder.ASTBuilder;
import parser.generated.SimpleJavaLexer;
import parser.generated.SimpleJavaParser;
import semantic.exeptions.AlreadyDeclearedException;
import semantic.exeptions.MultipleReturnTypes;
import semantic.exeptions.NotDeclearedException;
import semantic.exeptions.TypeMismatchException;
import java.io.IOException;
import java.nio.file.Paths;
import static org.junit.jupiter.api.Assertions.*;
public class EndToTAST {
@BeforeEach
public void setup(){
SemanticAnalyzer.clearAnalyzer();
}
@Test
public void CorrectTest(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/CorrectTest.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);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertEquals(SemanticAnalyzer.errors.size(), 0);
assertNotNull(tast);
}
@Test
public void notDecleared() {
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/NotDecleared.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);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
assertInstanceOf(NotDeclearedException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void typeMismatch(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/TypeMismatchIntBool.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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void parameterAlreadyDecleared(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/ParameterAlreadyDecleared.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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
assertInstanceOf(AlreadyDeclearedException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void fieldAlreadyDecleared(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/FieldAlreadyDecleared.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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
assertInstanceOf(AlreadyDeclearedException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void typeMismatchRefType(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/TypeMismatchRefType.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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void correctRetType(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/CorrectRetType.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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertTrue(SemanticAnalyzer.errors.isEmpty());
}
@Test
public void retTypeMismatch(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/retTypeMismatch.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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void multipleRetType(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/MultipleRetTypes.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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
assertInstanceOf(MultipleReturnTypes.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void wrongTypeInIfClause(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/WrongIfClause.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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
}
}

218
src/test/java/semantic/EndToTypedAstTest.java Normal file
View File

@ -0,0 +1,218 @@
package semantic;
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 ast.ASTNode;
import ast.ProgramNode;
import parser.astBuilder.ASTBuilder;
import parser.generated.SimpleJavaLexer;
import parser.generated.SimpleJavaParser;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
public class EndToTypedAstTest {
private static final Map<String, Class<?>> exceptionMap = new HashMap<>();
@Test
public void exceptionsTest() {
String directoryPath = "src/test/resources/input/typedAstExceptionsTests";
File folder = new File(directoryPath);
try {
loadCustomExceptions();
System.out.println("Custom exceptions loaded successfully.");
} catch (Exception e) {
throw new RuntimeException("Failed to load custom exceptions", e);
}
if (folder.isDirectory()) {
File[] files = folder.listFiles((_, name) -> name.endsWith(".java"));
if (files != null) {
for (File file : files) {
String expectedException = extractExpectedException(file);
SemanticAnalyzer.clearAnalyzer();
CharStream codeCharStream;
try {
codeCharStream = CharStreams.fromPath(Paths.get(file.getPath()));
} 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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
if (expectedException != null) {
System.out.println("Testing the file: " + file.getName());
assertFalse(SemanticAnalyzer.errors.isEmpty(), "Expected an exception, but none was found.");
assertInstanceOf(getExceptionClass(expectedException), SemanticAnalyzer.errors.getFirst());
} else {
System.out.println("No expected exception specified.");
// If no expected exception is specified, you might want to add a different check
// e.g., assertTrue(SemanticAnalyzer.errors.isEmpty(), "No exceptions expected, but some were found.");
}
}
} else {
System.out.println("No files found in the directory.");
}
} else {
System.out.println("The provided path is not a directory.");
}
}
@Test
public void featureTest(){
String directoryPath = "src/test/resources/input/typedAstFeaturesTests";
File folder = new File(directoryPath);
if (folder.isDirectory()) {
File[] files = folder.listFiles((_, name) -> name.endsWith(".java"));
if (files != null) {
for (File file : files) {
SemanticAnalyzer.clearAnalyzer();
CharStream codeCharStream;
try {
codeCharStream = CharStreams.fromPath(Paths.get(file.getPath()));
} 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();
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
System.out.println("Testing the file: " + file.getName());
assertTrue(SemanticAnalyzer.errors.isEmpty());
assertNotNull(typedAst);
}
} else {
System.out.println("No files found in the directory.");
}
} else {
System.out.println("The provided path is not a directory.");
}
}
// ------------------ Helpers ------------------
/**
* This method is used to extract the expected exception from a given file.
* It reads the file line by line and uses a regular expression to match the expected exception annotation.
* The expected exception annotation should be in the format: "// @expected: ExceptionName".
* If the expected exception annotation is found, it returns the name of the expected exception.
* If the expected exception annotation is not found, it returns null.
*
* @param file The file from which the expected exception is to be extracted.
* @return The name of the expected exception, or null if the expected exception annotation is not found.
*/
private String extractExpectedException(File file) {
String annotationPattern = "//\\s*@expected:\\s*(\\S+)";
Pattern pattern = Pattern.compile(annotationPattern);
try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
String line;
while ((line = reader.readLine()) != null) {
Matcher matcher = pattern.matcher(line);
if (matcher.find()) {
return matcher.group(1);
}
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* This method is used to retrieve the Class object associated with a given exception name.
* It first prints the original exception name, then appends the package name to the exception name and prints it.
* It then retrieves the Class object from the exceptionMap using the fully qualified exception name.
* If the Class object is not found in the exceptionMap, it throws a RuntimeException.
*
* @param exceptionName The name of the exception for which the Class object is to be retrieved.
* @return The Class object associated with the given exception name.
* @throws RuntimeException If the Class object for the given exception name is not found in the exceptionMap.
*/
private Class<?> getExceptionClass(String exceptionName) {
System.out.println(exceptionName);
exceptionName = "semantic.exceptions." + exceptionName;
System.out.println(exceptionName);
Class<?> exceptionClass = exceptionMap.get(exceptionName);
if (exceptionClass == null) {
throw new RuntimeException("Exception class not found: " + exceptionName);
}
return exceptionClass;
}
/**
* This method is used to load custom exceptions from a specified package.
* It first constructs the directory path from the package name and checks if the directory exists.
* If the directory does not exist, it throws an IllegalArgumentException.
* It then creates a URLClassLoader to load the classes from the directory.
* It iterates over all the files in the directory, and for each file, it constructs the class name and loads the class.
* If the loaded class is a subtype of Throwable, it adds the class to the exceptionMap.
*
* @throws Exception If any error occurs during class loading.
*/
private static void loadCustomExceptions() throws Exception {
final String packName = "semantic.exceptions";
final String dirForMyClasses = "src/main/java/%s".formatted(packName.replace(".", "/"));
File folder = new File(dirForMyClasses);
if (!folder.isDirectory()) {
throw new IllegalArgumentException("The provided path is not a directory.");
}
URL[] urls = {folder.toURI().toURL()};
URLClassLoader classLoader;
try {
classLoader = new URLClassLoader(urls);
} catch (Exception e) {
throw new RuntimeException("Failed to create class loader", e);
}
for (File file : Objects.requireNonNull(folder.listFiles())) {
String className = packName + "." + file.getName().replaceAll("\\.(?:class|java)$", "");
System.out.printf("Loading custom exception: %s (=> %s)", file.getName(), className);
Class<?> cls = classLoader.loadClass(className);
if (Throwable.class.isAssignableFrom(cls)) { // Check if the class is a subtype of Throwable
exceptionMap.put(className, cls);
System.out.println("Loaded custom exception: " + className);
}
}
}
}

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

@ -1,18 +1,5 @@
package semantic;
import ast.*;
import ast.member.FieldNode;
import ast.member.MemberNode;
import ast.member.MethodNode;
import ast.parameter.ParameterNode;
import org.junit.jupiter.api.Test;
import semantic.exeptions.AlreadyDeclearedException;
import java.util.ArrayList;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
public class SemanticTest {
@ -35,7 +22,7 @@ public class SemanticTest {
// ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
//
// assertEquals(1, SemanticAnalyzer.errors.size());
// assertInstanceOf(AlreadyDeclearedException.class, SemanticAnalyzer.errors.getFirst());
// assertInstanceOf(AlreadyDeclaredException.class, SemanticAnalyzer.errors.getFirst());
// assertNull(typedAst);
// }
//

2
src/test/resources/input/AllFeaturesClassExample.java
View File

@ -1,5 +1,3 @@
package resources;
public class AllFeaturesClassExample {
int a;
boolean b;

2
src/test/resources/input/CombinedExample.java
View File

@ -1,5 +1,3 @@
package resources;
public class CombinedExample {
int number;
boolean flag;

2
src/test/resources/input/MoreFeaturesClassExample.java
View File

@ -1,5 +1,3 @@
package resources;
public class MoreFeaturesClassExample {
int hallo;
private class Inner {

2
src/test/resources/input/featureTests/BooleanOperations.java
View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class BooleanOperations {
boolean flag;

2
src/test/resources/input/featureTests/CharManipulation.java
View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class CharManipulation {
char letter;

2
src/test/resources/input/featureTests/ConditionalStatements.java
View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class ConditionalStatements {
int number;

2
src/test/resources/input/featureTests/EmptyClassExample.java Normal file
View File

@ -0,0 +1,2 @@
public class EmptyClassExample {
}

2
src/test/resources/input/featureTests/LoopExamples.java
View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class LoopExamples {
public static void main(String[] args) {
// For loop example

2
src/test/resources/input/featureTests/MethodOverloading.java
View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class MethodOverloading {
public int add(int a, int b) {
return a + b;

1
src/test/resources/semantic/endToTAST/FieldAlreadyDecleared.java → src/test/resources/input/typedAstExceptionsTests/FieldAlreadyDeclared.java
View File

@ -1,3 +1,4 @@
// @expected: AlreadyDeclaredException
public class Example {
public int a;

1
src/test/resources/semantic/endToTAST/MultipleRetTypes.java → src/test/resources/input/typedAstExceptionsTests/MultipleReturnTypes.java
View File

@ -1,3 +1,4 @@
// @expected: MultipleReturnTypes
public class Example {
public static int testMethod(int x, char c){

1
src/test/resources/semantic/endToTAST/NotDecleared.java → src/test/resources/input/typedAstExceptionsTests/NotDeclared.java
View File

@ -1,3 +1,4 @@
// @expected: NotDeclaredException
public class Test {
public static int testMethod(int x){
int a = b;

1
src/test/resources/semantic/endToTAST/ParameterAlreadyDecleared.java → src/test/resources/input/typedAstExceptionsTests/ParameterAlreadyDeclared.java
View File

@ -1,3 +1,4 @@
// @expected: AlreadyDeclaredException
public class Example {
public static int testMethod(char a, int a){

1
src/test/resources/semantic/endToTAST/retTypeMismatch.java → src/test/resources/input/typedAstExceptionsTests/ReturnTypeMismatch.java
View File

@ -1,3 +1,4 @@
// @expected: TypeMismatchException
public class Example {
public static int testMethod(char x){

1
src/test/resources/semantic/endToTAST/TypeMismatchIntBool.java → src/test/resources/input/typedAstExceptionsTests/TypeMismatchIntBool.java
View File

@ -1,3 +1,4 @@
// @expected: TypeMismatchException
public class Test {
public boolean b;

1
src/test/resources/semantic/endToTAST/TypeMismatchRefType.java → src/test/resources/input/typedAstExceptionsTests/TypeMismatchRefType.java
View File

@ -1,3 +1,4 @@
// @expected: TypeMismatchException
public class Test {
public static int testMethod(ExampleA exampleA, ExampleB exampleB){

1
src/test/resources/semantic/endToTAST/WrongIfClause.java → src/test/resources/input/typedAstExceptionsTests/WrongIfClause.java
View File

@ -1,3 +1,4 @@
// @expected: TypeMismatchException
public class Example {
public static void testMethod(int x){

0
src/test/resources/semantic/endToTAST/CorrectRetType.java → src/test/resources/input/typedAstFeaturesTests/CorrectReturnType.java
View File

0
src/test/resources/semantic/endToTAST/CorrectTest.java → src/test/resources/input/typedAstFeaturesTests/CorrectTest.java
View File

0
src/test/resources/semantic/correctRefType.json → src/test/resources/trees/correctRefType.json
View File

0
src/test/resources/semantic/refTypeMismatch.json → src/test/resources/trees/refTypeMismatch.json
View File

0
src/test/resources/semantic/test.json → src/test/resources/trees/test.json
View File