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

Merge branch 'NewParser' into johns-branch
Some checks are pending
Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run
Details

Browse Source
This commit is contained in:
Bruder John 2024-06-21 10:47:54 +02:00
commit b5738034b0
43 changed files with 183 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,6 +1,7 @@
import ast.*;
import ast.ASTNode;
import org.antlr.v4.runtime.*;
import bytecode.ByteCodeGenerator;
import ast.ProgramNode;
//import bytecode.ByteCodeGenerator;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.tree.ParseTree;
@ -8,7 +9,7 @@ import org.antlr.v4.runtime.CommonTokenStream;
import parser.astBuilder.ASTBuilder;
import parser.generated.SimpleJavaLexer;
import parser.generated.SimpleJavaParser;
import semantic.SemanticAnalyzer;
//import semantic.SemanticAnalyzer;
import java.io.IOException;
import java.nio.file.Paths;
@ -59,7 +60,7 @@ public class Main {
/* ------------------------- AST builder -> AST ------------------------- */
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
System.out.println(abstractSyntaxTree);
// Printing the AST
// System.out.println("-------------------- AST builder -> AST --------------------");
// // System.out.println("AST: " + ast.toString());
@ -69,8 +70,8 @@ public class Main {
/*
* ------------------------- Semantic Analyzer -> Tast -------------------------
*/
SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
ProgramNode typedAst = (ProgramNode) semanticAnalyzer.generateTast(abstractSyntaxTree);
//SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
//ProgramNode typedAst = (ProgramNode) semanticAnalyzer.generateTast(abstractSyntaxTree);
// Printing the Tast
System.out.println("Tast generated");
@ -79,9 +80,9 @@ public class Main {
* ------------------------- Bytecode Generator -> Bytecode
* -------------------------
*/
ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator();
//ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator();
//byteCodeGenerator.generateByteCode(abstractSyntaxTree);
byteCodeGenerator.visit(typedAst);
//byteCodeGenerator.visit(typedAst);
System.out.println("Bytecode generated");
}

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

@ -1,19 +1,14 @@
package ast;
import ast.type.AccessModifierNode;
import ast.type.EnumAccessModifierNode;
import bytecode.visitor.ClassVisitor;
import ast.member.ConstructorNode;
import ast.member.MemberNode;
import ast.member.MethodNode;
import semantic.SemanticVisitor;
import typechecker.TypeCheckResult;
import visitor.Visitable;
import java.util.ArrayList;
import java.util.List;
public class ClassNode implements ASTNode, Visitable {
public class ClassNode implements ASTNode {
public AccessModifierNode accessType;
public String identifier;
public List<MemberNode> members = new ArrayList<>();
@ -50,14 +45,4 @@ public class ClassNode implements ASTNode, Visitable {
}
return methods;
}
@Override
public TypeCheckResult accept(SemanticVisitor visitor) {
return visitor.analyze(this);
}
@Override
public void accept(ClassVisitor classVisitor) {
classVisitor.visit(this);
}
}

4
src/main/java/ast/IdentifierNode.java
View File

@ -1,4 +0,0 @@
package ast;
public class IdentifierNode {
}

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

@ -1,27 +1,13 @@
package ast;
import bytecode.visitor.ProgramVisitor;
import semantic.SemanticVisitor;
import typechecker.TypeCheckResult;
import visitor.Visitable;
import java.util.ArrayList;
import java.util.List;
public class ProgramNode implements ASTNode, Visitable {
public class ProgramNode implements ASTNode {
public List<ClassNode> classes = new ArrayList<>();
public void addClass(ClassNode classNode) {
classes.add(classNode);
}
@Override
public TypeCheckResult accept(SemanticVisitor visitor) {
return visitor.analyze(this);
}
@Override
public void accept(ProgramVisitor programVisitor) {
programVisitor.visit(this);
}
}

11
src/main/java/ast/block/BlockNode.java
View File

@ -1,20 +1,17 @@
package ast.block;
import ast.ASTNode;
import ast.statement.StatementNode;
import semantic.SemanticVisitor;
import typechecker.TypeCheckResult;
import visitor.Visitable;
import ast.statement.IStatementNode;
import java.util.ArrayList;
import java.util.List;
public class BlockNode implements ASTNode, Visitable {
public List<StatementNode> statements = new ArrayList<>();
public class BlockNode implements ASTNode {
public List<IStatementNode> statements = new ArrayList<>();
public BlockNode() {}
public void addStatement(StatementNode statement) {
public void addStatement(IStatementNode statement) {
statements.add(statement);
}

6
src/main/java/ast/expression/ExpressionNode.java
View File

@ -1,6 +0,0 @@
package ast.expression;
import ast.ASTNode;
public class ExpressionNode implements ASTNode {
}

5
src/main/java/ast/expression/IExpressionNode.java Normal file
View File

@ -0,0 +1,5 @@
package ast.expression;
import ast.ASTNode;
public interface IExpressionNode extends ASTNode {}

4
src/main/java/ast/expression/binaryexpression/BinaryExpression.java
View File

@ -1,4 +0,0 @@
package ast.expression.binaryexpression;
public class BinaryExpression {
}

7
src/main/java/ast/expression/binaryexpression/BinaryExpressionNode.java Normal file
View File

@ -0,0 +1,7 @@
package ast.expression.binaryexpression;
import ast.expression.IExpressionNode;
import java.beans.Expression;
public class BinaryExpressionNode implements IExpressionNode {}

8
src/main/java/ast/expression/binaryexpression/CalculationExpressionNode.java
View File

@ -2,10 +2,10 @@ package ast.expression.binaryexpression;
import ast.ASTNode;
public class CalculationExpressionNode implements ASTNode {
CalculationExpressionNode calculationExpression;
String operator;
DotExpressionNode dotExpression;
public class CalculationExpressionNode extends BinaryExpressionNode {
public CalculationExpressionNode calculationExpression;
public String operator;
public DotExpressionNode dotExpression;
public CalculationExpressionNode(CalculationExpressionNode calculationExpression, String operator, DotExpressionNode dotExpression) {
this.calculationExpression = calculationExpression;

8
src/main/java/ast/expression/binaryexpression/DotExpressionNode.java
View File

@ -2,10 +2,10 @@ package ast.expression.binaryexpression;
import ast.ASTNode;
public class DotExpressionNode implements ASTNode {
DotExpressionNode dotExpression;
String operator;
DotSubstractionExpressionNode dotSubstractionExpression;
public class DotExpressionNode extends BinaryExpressionNode {
public DotExpressionNode dotExpression;
public String operator;
public DotSubstractionExpressionNode dotSubstractionExpression;
public DotExpressionNode(DotExpressionNode dotExpression, String operator, DotSubstractionExpressionNode dotSubstractionExpression) {
this.dotExpression = dotExpression;

12
src/main/java/ast/expression/binaryexpression/DotSubstractionExpressionNode.java
View File

@ -5,12 +5,12 @@ import ast.expression.unaryexpression.MemberAccessNode;
import ast.statement.statementexpression.methodcallstatementnexpression.MethodCallStatementExpressionNode;
import ast.type.ValueNode;
public class DotSubstractionExpressionNode implements ASTNode {
ValueNode value;
String identifier;
MemberAccessNode memberAccess;
MethodCallStatementExpressionNode methodCall;
CalculationExpressionNode calculationExpression;
public class DotSubstractionExpressionNode extends BinaryExpressionNode {
public ValueNode value;
public String identifier;
public MemberAccessNode memberAccess;
public MethodCallStatementExpressionNode methodCall;
public CalculationExpressionNode calculationExpression;
public DotSubstractionExpressionNode(ValueNode value) {
this.value = value;

12
src/main/java/ast/expression/binaryexpression/NonCalculationExpressionNode.java
View File

@ -1,15 +1,15 @@
package ast.expression.binaryexpression;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
import ast.expression.unaryexpression.UnaryExpressionNode;
public class NonCalculationExpressionNode implements ASTNode {
UnaryExpressionNode unaryExpression;
String operator;
ExpressionNode expression;
public class NonCalculationExpressionNode extends BinaryExpressionNode {
public UnaryExpressionNode unaryExpression;
public String operator;
public IExpressionNode expression;
public NonCalculationExpressionNode(UnaryExpressionNode unaryExpression, String operator, ExpressionNode expression) {
public NonCalculationExpressionNode(UnaryExpressionNode unaryExpression, String operator, IExpressionNode expression) {
this.unaryExpression = unaryExpression;
this.operator = operator;
this.expression = expression;

4
src/main/java/ast/expression/unaryexpression/MemberAccessNode.java
View File

@ -6,8 +6,8 @@ import java.util.ArrayList;
import java.util.List;
public class MemberAccessNode implements ASTNode {
Boolean thisExpr;
List<String> identifiers = new ArrayList<>();
public Boolean thisExpr;
public List<String> identifiers = new ArrayList<>();
public MemberAccessNode(Boolean thisExpr) {
this.thisExpr = thisExpr;

6
src/main/java/ast/expression/unaryexpression/NotExpressionNode.java
View File

@ -1,12 +1,12 @@
package ast.expression.unaryexpression;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
public class NotExpressionNode implements ASTNode {
ExpressionNode expression;
public IExpressionNode expression;
public NotExpressionNode(ExpressionNode expression) {
public NotExpressionNode(IExpressionNode expression) {
this.expression = expression;
}
}

25
src/main/java/ast/expression/unaryexpression/UnaryExpressionNode.java
View File

@ -1,20 +1,19 @@
package ast.expression.unaryexpression;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.statement.StatementNode;
import ast.expression.IExpressionNode;
import ast.statement.IStatementNode;
import ast.type.ValueNode;
import java.util.Objects;
public class UnaryExpressionNode extends ExpressionNode {
String thisExp;
String identifier;
MemberAccessNode memberAccess;
ValueNode value;
NotExpressionNode notExpression;
StatementNode statement;
ExpressionNode expression;
public class UnaryExpressionNode implements IExpressionNode {
public String thisExp;
public String identifier;
public MemberAccessNode memberAccess;
public ValueNode value;
public NotExpressionNode notExpression;
public IStatementNode statement;
public IExpressionNode expression;
public UnaryExpressionNode(String value) {
if(Objects.equals(value, "this")) {
@ -36,11 +35,11 @@ public class UnaryExpressionNode extends ExpressionNode {
this.notExpression = notExpression;
}
public UnaryExpressionNode(StatementNode statement) {
public UnaryExpressionNode(IStatementNode statement) {
this.statement = statement;
}
public UnaryExpressionNode(ExpressionNode expression) {
public UnaryExpressionNode(IExpressionNode expression) {
this.expression = expression;
}
}

12
src/main/java/ast/member/ConstructorNode.java
View File

@ -3,8 +3,6 @@ package ast.member;
import ast.block.BlockNode;
import ast.parameter.ParameterNode;
import ast.type.AccessModifierNode;
import bytecode.visitor.MethodVisitor;
import visitor.Visitable;
import java.util.ArrayList;
import java.util.List;
@ -20,8 +18,8 @@ public class ConstructorNode extends MethodNode {
this.identifier = identifier;
}
public ConstructorNode(AccessModifierNode accessType, String identifier, BlockNode body) {
this.accessType = accessType;
public ConstructorNode(String accessType, String identifier, BlockNode body) {
this.accessType = new AccessModifierNode(accessType);
this.identifier = identifier;
this.body = body;
}
@ -30,10 +28,4 @@ public class ConstructorNode extends MethodNode {
parameters.add(parameterNode);
}
/*
@Override
public void accept(MethodVisitor methodVisitor) {
methodVisitor.visit(this);
}
*/
}

16
src/main/java/ast/member/FieldNode.java
View File

@ -2,12 +2,8 @@ package ast.member;
import ast.type.AccessModifierNode;
import ast.type.TypeNode;
import bytecode.visitor.ClassVisitor;
import semantic.SemanticVisitor;
import typechecker.TypeCheckResult;
import visitor.Visitable;
public class FieldNode implements MemberNode, Visitable {
public class FieldNode implements MemberNode {
public AccessModifierNode accessTypeNode;
public TypeNode type;
public String identifier;
@ -17,14 +13,4 @@ public class FieldNode implements MemberNode, Visitable {
this.type = type;
this.identifier = name;
}
@Override
public TypeCheckResult accept(SemanticVisitor visitor) {
return visitor.analyze(this);
}
@Override
public void accept(ClassVisitor classVisitor) {
classVisitor.visit(this);
}
}

18
src/main/java/ast/member/MethodNode.java
View File

@ -4,20 +4,16 @@ import ast.block.BlockNode;
import ast.parameter.ParameterNode;
import ast.type.AccessModifierNode;
import ast.type.TypeNode;
import bytecode.visitor.MethodVisitor;
import semantic.SemanticVisitor;
import typechecker.TypeCheckResult;
import visitor.Visitable;
import java.util.ArrayList;
import java.util.List;
public class MethodNode implements MemberNode, Visitable {
AccessModifierNode accesModifier;
public class MethodNode implements MemberNode {
public AccessModifierNode accesModifier;
public TypeNode type;
Boolean voidType;
public Boolean voidType;
public String identifier;
private List<ParameterNode> parameters = new ArrayList<>();
public List<ParameterNode> parameters = new ArrayList<>();
public BlockNode block;
public MethodNode() {}
@ -26,9 +22,9 @@ public class MethodNode implements MemberNode, Visitable {
this.block = block;
}
public MethodNode(AccessModifierNode accessModifier, TypeNode type, Boolean voidType, String identifier, BlockNode block){
this.accesModifier = accessModifier;
this.type = type;
public MethodNode(String accessModifier, String type, Boolean voidType, String identifier, BlockNode block){
this.accesModifier = new AccessModifierNode(accessModifier);
this.type = new TypeNode(type);
this.voidType = voidType;
this.identifier = identifier;
this.block = block;

16
src/main/java/ast/statement/ForStatementNode.java
View File

@ -1,21 +1,21 @@
package ast.statement;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
public class ForStatementNode implements ASTNode {
ExpressionNode statementExpressionInit;
StatementNode localVariableDeclarationInit;
ExpressionNode expression;
ExpressionNode statementExpression;
public class ForStatementNode implements IStatementNode {
public IExpressionNode statementExpressionInit;
public IStatementNode localVariableDeclarationInit;
public IExpressionNode expression;
public IExpressionNode statementExpression;
public ForStatementNode(ExpressionNode statementExpressionInit, ExpressionNode expression, ExpressionNode statementExpression) {
public ForStatementNode(IExpressionNode statementExpressionInit, IExpressionNode expression, IExpressionNode statementExpression) {
this.statementExpressionInit = statementExpressionInit;
this.expression = expression;
this.statementExpression = statementExpression;
}
public ForStatementNode(StatementNode localVariableDeclarationInit, ExpressionNode expression, ExpressionNode statementExpression) {
public ForStatementNode(IStatementNode localVariableDeclarationInit, IExpressionNode expression, IExpressionNode statementExpression) {
this.localVariableDeclarationInit = localVariableDeclarationInit;
this.expression = expression;
this.statementExpression = statementExpression;

6
src/main/java/ast/statement/IStatementNode.java Normal file
View File

@ -0,0 +1,6 @@
package ast.statement;
import ast.ASTNode;
public interface IStatementNode extends ASTNode {
}

14
src/main/java/ast/statement/LocalVariableDeclarationNode.java
View File

@ -1,16 +1,16 @@
package ast.statement;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
import ast.type.TypeNode;
public class LocalVariableDeclarationNode extends StatementNode {
TypeNode type;
String identifier;
String assign;
ExpressionNode expression;
public class LocalVariableDeclarationNode implements IStatementNode {
public TypeNode type;
public String identifier;
public String assign;
public IExpressionNode expression;
public LocalVariableDeclarationNode(TypeNode type, String identifier, String assign, ExpressionNode expression) {
public LocalVariableDeclarationNode(TypeNode type, String identifier, String assign, IExpressionNode expression) {
this.type = type;
this.identifier = identifier;
this.assign = assign;

8
src/main/java/ast/statement/ReturnStatementNode.java
View File

@ -1,12 +1,12 @@
package ast.statement;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
public class ReturnStatementNode implements ASTNode {
public ExpressionNode expression;
public class ReturnStatementNode implements IStatementNode {
public IExpressionNode expression;
public ReturnStatementNode(ExpressionNode expression) {
public ReturnStatementNode(IExpressionNode expression) {
this.expression = expression;
}
}

6
src/main/java/ast/statement/StatementNode.java
View File

@ -1,6 +0,0 @@
package ast.statement;
import ast.ASTNode;
public class StatementNode implements ASTNode {
}

10
src/main/java/ast/statement/WhileStatementNode.java
View File

@ -2,13 +2,13 @@ package ast.statement;
import ast.ASTNode;
import ast.block.BlockNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
public class WhileStatementNode implements ASTNode {
ExpressionNode expression;
BlockNode block;
public class WhileStatementNode implements IStatementNode {
public IExpressionNode expression;
public BlockNode block;
public WhileStatementNode(ExpressionNode expression, BlockNode block) {
public WhileStatementNode(IExpressionNode expression, BlockNode block) {
this.expression = expression;
this.block = block;
}

5
src/main/java/ast/statement/ifstatement/ElseStatementNode.java
View File

@ -2,9 +2,10 @@ package ast.statement.ifstatement;
import ast.ASTNode;
import ast.block.BlockNode;
import ast.statement.IStatementNode;
public class ElseStatementNode implements ASTNode {
BlockNode block;
public class ElseStatementNode implements IStatementNode {
public BlockNode block;
public ElseStatementNode(BlockNode block) {
this.block = block;

7
src/main/java/ast/statement/ifstatement/IfElseStatementNode.java
View File

@ -1,13 +1,14 @@
package ast.statement.ifstatement;
import ast.ASTNode;
import ast.statement.IStatementNode;
import java.util.ArrayList;
import java.util.List;
public class IfElseStatementNode implements ASTNode {
IfStatementNode ifStatement;
List<ElseStatementNode> elseStatements = new ArrayList<>();
public class IfElseStatementNode implements IStatementNode {
public IfStatementNode ifStatement;
public List<ElseStatementNode> elseStatements = new ArrayList<>();
public IfElseStatementNode(IfStatementNode ifStatement) {
this.ifStatement = ifStatement;

11
src/main/java/ast/statement/ifstatement/IfStatementNode.java
View File

@ -2,13 +2,14 @@ package ast.statement.ifstatement;
import ast.ASTNode;
import ast.block.BlockNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
import ast.statement.IStatementNode;
public class IfStatementNode implements ASTNode {
ExpressionNode expression;
BlockNode block;
public class IfStatementNode implements IStatementNode {
public IExpressionNode expression;
public BlockNode block;
public IfStatementNode(ExpressionNode expression, BlockNode block) {
public IfStatementNode(IExpressionNode expression, BlockNode block) {
this.expression = expression;
this.block = block;
}

10
src/main/java/ast/statement/statementexpression/AssignStatementExpressionNode.java
View File

@ -1,13 +1,13 @@
package ast.statement.statementexpression;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
public class AssignStatementExpressionNode implements ASTNode {
AssignableExpressionNode assignable;
ExpressionNode expression;
public class AssignStatementExpressionNode implements IStatementExpressionNode {
public AssignableExpressionNode assignable;
public IExpressionNode expression;
public AssignStatementExpressionNode(AssignableExpressionNode assignable, ExpressionNode expression) {
public AssignStatementExpressionNode(AssignableExpressionNode assignable, IExpressionNode expression) {
this.assignable = assignable;
this.expression = expression;
}

6
src/main/java/ast/statement/statementexpression/AssignableExpressionNode.java
View File

@ -3,9 +3,9 @@ package ast.statement.statementexpression;
import ast.ASTNode;
import ast.expression.unaryexpression.MemberAccessNode;
public class AssignableExpressionNode implements ASTNode {
String identifier;
MemberAccessNode memberAccess;
public class AssignableExpressionNode implements IStatementExpressionNode {
public String identifier;
public MemberAccessNode memberAccess;
public AssignableExpressionNode(String identifier) {
this.identifier = identifier;

5
src/main/java/ast/statement/statementexpression/IStatementExpressionNode.java Normal file
View File

@ -0,0 +1,5 @@
package ast.statement.statementexpression;
import ast.statement.IStatementNode;
public interface IStatementExpressionNode extends IStatementNode {}

5
src/main/java/ast/statement/statementexpression/IncrementExpression.java
View File

@ -1,5 +0,0 @@
package ast.statement.statementexpression;
public class IncrementExpression {
}

10
src/main/java/ast/statement/statementexpression/NewDeclarationStatementExpressionNode.java
View File

@ -1,20 +1,20 @@
package ast.statement.statementexpression;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
import java.util.ArrayList;
import java.util.List;
public class NewDeclarationStatementExpressionNode implements ASTNode {
String identifier;
List<ExpressionNode> expressions = new ArrayList<>();
public class NewDeclarationStatementExpressionNode implements IStatementExpressionNode {
public String identifier;
public List<IExpressionNode> expressions = new ArrayList<>();
public NewDeclarationStatementExpressionNode(String identifier) {
this.identifier = identifier;
}
public void addExpression(ExpressionNode expression) {
public void addExpression(IExpressionNode expression) {
expressions.add(expression);
}
}

7
src/main/java/ast/statement/statementexpression/crementExpression/DecrementExpressionNode.java
View File

@ -2,10 +2,11 @@ package ast.statement.statementexpression.crementExpression;
import ast.ASTNode;
import ast.statement.statementexpression.AssignableExpressionNode;
import ast.statement.statementexpression.IStatementExpressionNode;
public class DecrementExpressionNode implements ASTNode {
CrementType crementType;
AssignableExpressionNode assignableExpression;
public class DecrementExpressionNode implements IStatementExpressionNode {
public CrementType crementType;
public AssignableExpressionNode assignableExpression;
public DecrementExpressionNode(CrementType crementType, AssignableExpressionNode assignableExpression) {
this.assignableExpression = assignableExpression;

7
src/main/java/ast/statement/statementexpression/crementExpression/IncrementExpressionNode.java
View File

@ -2,10 +2,11 @@ package ast.statement.statementexpression.crementExpression;
import ast.ASTNode;
import ast.statement.statementexpression.AssignableExpressionNode;
import ast.statement.statementexpression.IStatementExpressionNode;
public class IncrementExpressionNode implements ASTNode {
CrementType crementType;
AssignableExpressionNode assignableExpression;
public class IncrementExpressionNode implements IStatementExpressionNode {
public CrementType crementType;
public AssignableExpressionNode assignableExpression;
public IncrementExpressionNode(CrementType crementType, AssignableExpressionNode assignableExpression) {
this.assignableExpression = assignableExpression;

8
src/main/java/ast/statement/statementexpression/methodcallstatementnexpression/ChainedMethodNode.java
View File

@ -1,20 +1,20 @@
package ast.statement.statementexpression.methodcallstatementnexpression;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
import java.util.ArrayList;
import java.util.List;
public class ChainedMethodNode implements ASTNode {
String identifier;
List<ExpressionNode> expressions = new ArrayList<>();
public String identifier;
public List<IExpressionNode> expressions = new ArrayList<>();
public ChainedMethodNode(String identifier) {
this.identifier = identifier;
}
public void addExpression(ExpressionNode expression) {
public void addExpression(IExpressionNode expression) {
expressions.add(expression);
}
}

15
src/main/java/ast/statement/statementexpression/methodcallstatementnexpression/MethodCallStatementExpressionNode.java
View File

@ -1,16 +1,17 @@
package ast.statement.statementexpression.methodcallstatementnexpression;
import ast.ASTNode;
import ast.expression.ExpressionNode;
import ast.expression.IExpressionNode;
import ast.statement.statementexpression.IStatementExpressionNode;
import java.util.ArrayList;
import java.util.List;
public class MethodCallStatementExpressionNode implements ASTNode {
TargetNode target;
List<ChainedMethodNode> chainedMethods = new ArrayList<>();
String identifier;
List<ExpressionNode> expressions = new ArrayList<>();
public class MethodCallStatementExpressionNode implements IStatementExpressionNode {
public TargetNode target;
public List<ChainedMethodNode> chainedMethods = new ArrayList<>();
public String identifier;
public List<IExpressionNode> expressions = new ArrayList<>();
public MethodCallStatementExpressionNode(TargetNode target, String identifier) {
this.target = target;
@ -21,7 +22,7 @@ public class MethodCallStatementExpressionNode implements ASTNode {
chainedMethods.add(chainedMethode);
}
public void addExpression(ExpressionNode expression) {
public void addExpression(IExpressionNode expression) {
expressions.add(expression);
}

8
src/main/java/ast/statement/statementexpression/methodcallstatementnexpression/TargetNode.java
View File

@ -5,10 +5,10 @@ import ast.expression.unaryexpression.MemberAccessNode;
import ast.statement.statementexpression.NewDeclarationStatementExpressionNode;
public class TargetNode implements ASTNode {
Boolean thisTar;
MemberAccessNode memberAccess;
NewDeclarationStatementExpressionNode newDeclaration;
String identifier;
public Boolean thisTar;
public MemberAccessNode memberAccess;
public NewDeclarationStatementExpressionNode newDeclaration;
public String identifier;
public TargetNode(Boolean thisTar) {
this.thisTar = thisTar;

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

@ -1,7 +1,7 @@
package ast.type;
public class AccessModifierNode {
EnumAccessModifierNode accessType;
public EnumAccessModifierNode accessType;
public AccessModifierNode(String accessModifier) {
setModifier(accessModifier);

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

@ -1,7 +1,7 @@
package ast.type;
public class TypeNode {
EnumTypeNode type;
public EnumTypeNode type;
public TypeNode(String type) {
setType(type);

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

@ -3,8 +3,8 @@ package ast.type;
import ast.ASTNode;
public class ValueNode implements ASTNode {
EnumValueNode valueType;
String value;
public EnumValueNode valueType;
public String value;
public ValueNode(EnumValueNode valueType, String value) {
this.valueType = valueType;

36
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((AccessModifierNode) visit(ctx.AccessModifier()), ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
ConstructorNode constructorNode = new ConstructorNode(ctx.AccessModifier().getText(), ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
constructorNode.addParameter((ParameterNode) visit(parameter));
}
@ -66,13 +66,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
return new MethodNode((BlockNode) visit(ctx.block()));
} else {
if(ctx.type() != null) {
MethodNode methodNode = new MethodNode((AccessModifierNode) visit(ctx.AccessModifier()), (TypeNode) visit(ctx.type()), false, ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
MethodNode methodNode = new MethodNode(ctx.AccessModifier().getText(), ctx.type().getText(), false, ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
methodNode.addParameter((ParameterNode) visit(parameter));
}
return methodNode;
} else {
MethodNode methodNode = new MethodNode((AccessModifierNode) visit(ctx.AccessModifier()), null, true, ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
MethodNode methodNode = new MethodNode(ctx.AccessModifier().getText(), null, true, ctx.Identifier().getText(), (BlockNode) visit(ctx.block()));
for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
// methodNode.addParameter((ParameterNode) visit(parameter));
}
@ -108,34 +108,34 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitReturnStatement(SimpleJavaParser.ReturnStatementContext ctx) {
return new ReturnStatementNode((ExpressionNode) visit(ctx.expression()));
return new ReturnStatementNode((IExpressionNode) visit(ctx.expression()));
}
@Override
public ASTNode visitLocalVariableDeclaration(SimpleJavaParser.LocalVariableDeclarationContext ctx) {
return new LocalVariableDeclarationNode(new TypeNode(ctx.type().getText()), ctx.Identifier().getText(), ctx.Assign().getText(), (ExpressionNode) visit(ctx.expression()));
return new LocalVariableDeclarationNode(new TypeNode(ctx.type().getText()), ctx.Identifier().getText(), ctx.Assign().getText(), (IExpressionNode) visit(ctx.expression()));
}
@Override
public ASTNode visitBlock(SimpleJavaParser.BlockContext ctx) {
BlockNode blockNode = new BlockNode();
for(SimpleJavaParser.StatementContext statement : ctx.statement()) {
blockNode.addStatement((StatementNode) visit(statement));
blockNode.addStatement((IStatementNode) visit(statement));
}
return blockNode;
}
@Override
public ASTNode visitWhileStatement(SimpleJavaParser.WhileStatementContext ctx) {
return new WhileStatementNode((ExpressionNode) visit(ctx.expression()), (BlockNode) visit(ctx.block()));
return new WhileStatementNode((IExpressionNode) visit(ctx.expression()), (BlockNode) visit(ctx.block()));
}
@Override
public ASTNode visitForStatement(SimpleJavaParser.ForStatementContext ctx) {
if(ctx.statementExpression(0) != null) {
return new ForStatementNode((ExpressionNode) visit(ctx.statementExpression(0)), (ExpressionNode) visit(ctx.expression()), (ExpressionNode) visit(ctx.statementExpression(1)));
return new ForStatementNode((IExpressionNode) visit(ctx.statementExpression(0)), (IExpressionNode) visit(ctx.expression()), (IExpressionNode) visit(ctx.statementExpression(1)));
} else if(ctx.localVariableDeclaration() != null) {
return new ForStatementNode((StatementNode) visit(ctx.localVariableDeclaration()), (ExpressionNode) visit(ctx.expression()), (ExpressionNode) visit(ctx.statementExpression(1)));
return new ForStatementNode((IStatementNode) visit(ctx.localVariableDeclaration()), (IExpressionNode) visit(ctx.expression()), (IExpressionNode) visit(ctx.statementExpression(1)));
}
return null;
}
@ -151,7 +151,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitIfStatement(SimpleJavaParser.IfStatementContext ctx) {
return new IfStatementNode((ExpressionNode) visit(ctx.expression()), (BlockNode) visit(ctx.block()));
return new IfStatementNode((IExpressionNode) visit(ctx.expression()), (BlockNode) visit(ctx.block()));
}
@Override
@ -175,14 +175,14 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitAssign(SimpleJavaParser.AssignContext ctx) {
return new AssignStatementExpressionNode((AssignableExpressionNode) visit(ctx.assignableExpression()), (ExpressionNode) visit(ctx.expression()));
return new AssignStatementExpressionNode((AssignableExpressionNode) visit(ctx.assignableExpression()), (IExpressionNode) visit(ctx.expression()));
}
@Override
public ASTNode visitNewDeclaration(SimpleJavaParser.NewDeclarationContext ctx) {
NewDeclarationStatementExpressionNode newDeclarationStatementExpressionNode = new NewDeclarationStatementExpressionNode(ctx.Identifier().getText());
for(SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
newDeclarationStatementExpressionNode.addExpression((ExpressionNode) visit(expression));
newDeclarationStatementExpressionNode.addExpression((IExpressionNode) visit(expression));
}
return newDeclarationStatementExpressionNode;
}
@ -194,7 +194,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
methodCallStatementExpressionNode.addChainedMethod((ChainedMethodNode) visit(chainedMethod));
}
for(SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
methodCallStatementExpressionNode.addExpression((ExpressionNode) visit(expression));
methodCallStatementExpressionNode.addExpression((IExpressionNode) visit(expression));
}
return methodCallStatementExpressionNode;
}
@ -217,7 +217,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
public ASTNode visitChainedMethod(SimpleJavaParser.ChainedMethodContext ctx) {
ChainedMethodNode chainedMethodNode = new ChainedMethodNode(ctx.Identifier().getText());
for(SimpleJavaParser.ExpressionContext expression : ctx.argumentList().expression()) {
chainedMethodNode.addExpression((ExpressionNode) visit(expression));
chainedMethodNode.addExpression((IExpressionNode) visit(expression));
}
return chainedMethodNode;
}
@ -295,9 +295,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
} else if(ctx.notExpression() != null) {
return new UnaryExpressionNode((NotExpressionNode) visitNotExpression(ctx.notExpression()));
} else if(ctx.statementExpression() != null) {
return new UnaryExpressionNode((StatementNode) visitStatementExpression(ctx.statementExpression()));
return new UnaryExpressionNode((IStatementNode) visitStatementExpression(ctx.statementExpression()));
} else if(ctx.expression() != null) {
return new UnaryExpressionNode((ExpressionNode) visitExpression(ctx.expression()));
return new UnaryExpressionNode((IExpressionNode) visitExpression(ctx.expression()));
}
return null;
}
@ -332,7 +332,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitNotExpression(SimpleJavaParser.NotExpressionContext ctx) {
return new NotExpressionNode((ExpressionNode) visitExpression(ctx.expression()));
return new NotExpressionNode((IExpressionNode) visitExpression(ctx.expression()));
}
@ -382,7 +382,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
@Override
public ASTNode visitNonCalculationExpression(SimpleJavaParser.NonCalculationExpressionContext ctx) {
return new NonCalculationExpressionNode((UnaryExpressionNode) visit(ctx.unaryExpression()), ctx.nonCalculationOperator().getText(), (ExpressionNode) visit(ctx.expression()));
return new NonCalculationExpressionNode((UnaryExpressionNode) visit(ctx.unaryExpression()), ctx.nonCalculationOperator().getText(), (IExpressionNode) visit(ctx.expression()));
}
@Override

5
src/main/resources/CompilerInput.java
View File

@ -11,8 +11,7 @@ public class Example {
public class Test {
public static int testMethod(char x, int a){
x = x + a;
return x;
}
}