i22006/Compilerbau2024AbsolutNichtHaskell
i22006/Compilerbau2024AbsolutNichtHaskell
2
0
Fork 0
mirror of https://github.com/JonathanFleischmann/CompilerULTIMATE.git synced 2024-10-06 18:21:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added some Implementation of convertToTypedAST

Browse Source
This commit is contained in:
ahmad 2024-05-05 20:55:49 +02:00
parent cabadd7594
commit f87b014584
27 changed files with 295 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/main/java/de/maishai/typedast/TypeMapper.java Normal file
View File

@ -0,0 +1,28 @@
package de.maishai.typedast;
public class TypeMapper {
public static Type getType(de.maishai.ast.Type type) {
if (type == de.maishai.ast.Type.CHAR) {
return Type.CHAR;
} else if (type == de.maishai.ast.Type.BOOL) {
return Type.BOOL;
} else if (type == de.maishai.ast.Type.INT) {
return Type.INT;
}
throw new RuntimeException("Unknown type");
}
public static Type getReturnType(de.maishai.ast.ReturnType type) {
if (type == de.maishai.ast.ReturnType.CHAR) {
return Type.CHAR;
} else if (type == de.maishai.ast.ReturnType.BOOL) {
return Type.BOOL;
} else if (type == de.maishai.ast.ReturnType.INT) {
return Type.INT;
} else if (type == de.maishai.ast.ReturnType.VOID) {
return Type.VOID;
}
throw new RuntimeException("Unknown type");
}
}

26
src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java
View File

@ -1,6 +1,7 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.AssignSign;
import de.maishai.ast.records.Assignment;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
@ -8,6 +9,7 @@ import de.maishai.typedast.Type;
import lombok.Data;
import java.util.Map;
@Data
public class TypedAssignment implements Statement {
private TypedId loc;
@ -16,19 +18,27 @@ public class TypedAssignment implements Statement {
@Override
public Type typeCheck(Map<String, Type> localVar, Map<String, TypedClass> classes) {
if(!localVar.containsKey(loc.getName())) {
if (!localVar.containsKey(loc.getName())) {
throw new RuntimeException("Variable not declared");
}
}
//ASSIGN : '=';ADD_ASSIGN : '+='; SUB_ASSIGN : '-='; MUL_ASSIGN : '*=';
if (assignSign == AssignSign.ASSIGN || assignSign == AssignSign.ADD_ASSIGN ||
assignSign == AssignSign.SUB_ASSIGN || assignSign == AssignSign.MUL_ASSIGN) {
if (localVar.get(loc.getName()) != Type.INT || value.typeCheck(localVar, classes) != Type.INT) {
throw new RuntimeException("Type mismatch");
}
}
if(value.typeCheck(localVar, classes) != localVar.get(loc.getName())) {
throw new RuntimeException("Type mismatch");
}
return localVar.get(loc.getName());
return localVar.get(loc.getName());
}
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Assignment untyped = (Assignment) unTypedAST;
TypedAssignment typedAssignment = new TypedAssignment();
typedAssignment.setLoc((TypedId) loc.convertToTypedAST(localVar, classes, untyped.loc()));
typedAssignment.setAssignSign(untyped.assignment());
typedAssignment.setValue((Expression) value.convertToTypedAST(localVar, classes, untyped.value()));
return typedAssignment;
}
}

43
src/main/java/de/maishai/typedast/typedclass/TypedBinary.java
View File

@ -1,6 +1,7 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.Operator;
import de.maishai.ast.records.Binary;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
@ -14,24 +15,42 @@ public class TypedBinary implements Expression {
private Expression right;
@Override
public Type typeCheck(Map<String, Type> localVar, Map<String, TypedClass> classes) {
if(left.typeCheck(localVar, classes) == Type.INT &&
right.typeCheck(localVar, classes) == Type.INT) {
return Type.INT;
} else if(left.typeCheck(localVar, classes) == Type.BOOL &&
right.typeCheck(localVar, classes) == Type.BOOL) {
return Type.BOOL;
} else if(left.typeCheck(localVar, classes) == Type.CHAR &&
right.typeCheck(localVar, classes) == Type.CHAR) {
return Type.CHAR;
if(op == Operator.ADD || op == Operator.SUB || op == Operator.MUL) {
if (left.typeCheck(localVar, classes) == Type.INT &&
right.typeCheck(localVar, classes) == Type.INT) {
return Type.INT;
} else {
throw new RuntimeException("Type mismatch");
}
}else if(op == Operator.GT || op == Operator.LT || op == Operator.GE || op == Operator.LE || op == Operator.EQ || op == Operator.NE || op == Operator.AND || op == Operator.OR) {
if (left.typeCheck(localVar, classes) == Type.INT &&
right.typeCheck(localVar, classes) == Type.INT) {
return Type.BOOL;
} else {
throw new RuntimeException("Type mismatch");
}
} else if (op == Operator.AND || op == Operator.OR) {
if (left.typeCheck(localVar, classes) == Type.BOOL &&
right.typeCheck(localVar, classes) == Type.BOOL) {
return Type.BOOL;
} else {
throw new RuntimeException("Type mismatch");
}
} else {
throw new RuntimeException("Type mismatch");
throw new RuntimeException("Invalid operator");
}
}
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Binary binary = (Binary) unTypedAST;
TypedBinary typedBinary = new TypedBinary();
typedBinary.setLeft((Expression) this.left.convertToTypedAST(localVar, classes, binary.left()));
typedBinary.setOp(binary.op());
typedBinary.setRight((Expression) this.right.convertToTypedAST(localVar, classes, binary.right()));
return typedBinary;
}
}

15
src/main/java/de/maishai/typedast/typedclass/TypedBlock.java
View File

@ -1,5 +1,7 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.Block;
import de.maishai.ast.records.LocalVariable;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
import de.maishai.typedast.Type;
@ -27,6 +29,19 @@ public class TypedBlock implements Node {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
Block untyped = (Block) unTypedAST;
TypedBlock typedBlock = new TypedBlock();
for(LocalVariable var : untyped.vars()){
TypedLocalVariable typedVar = new TypedLocalVariable();
typedVar.convertToTypedAST(localVar, classes, var);
typedBlock.getVars().add(typedVar);
}
for(de.maishai.ast.records.Statement stmt : untyped.stmts()){
//TODO: Implement the conversion of the statements
}
return null;
}
}

3
src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java
View File

@ -1,5 +1,6 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.BoolLiteral;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
@ -18,7 +19,7 @@ public class TypedBoolLiteral implements Expression {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
de.maishai.ast.records.BoolLiteral untyped = (de.maishai.ast.records.BoolLiteral) unTypedAST;
BoolLiteral untyped = (BoolLiteral) unTypedAST;
TypedBoolLiteral typedBoolLiteral = new TypedBoolLiteral();
typedBoolLiteral.setValue(untyped.value());
return typedBoolLiteral;

2
src/main/java/de/maishai/typedast/typedclass/TypedBreak.java
View File

@ -15,6 +15,6 @@ public class TypedBreak implements Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
return new TypedBreak();
}
}

6
src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java
View File

@ -1,5 +1,6 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.CharLiteral;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
@ -16,6 +17,9 @@ public class TypedCharLiteral implements Expression {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
CharLiteral untyped = (CharLiteral) unTypedAST;
TypedCharLiteral typedCharLiteral = new TypedCharLiteral();
typedCharLiteral.setValue(untyped.value());
return typedCharLiteral;
}
}

8
src/main/java/de/maishai/typedast/typedclass/TypedClass.java
View File

@ -19,6 +19,7 @@ public class TypedClass implements Node {
@Override
public Type typeCheck(Map<String, Type> localVar, Map<String, TypedClass> classes) {
if(classes.containsKey(typedId.getName())) {
throw new RuntimeException("Class " + typedId.getName() + " already exists");
}
@ -44,8 +45,13 @@ public class TypedClass implements Node {
TypedClass typedClass = new TypedClass();
for (TypedField field: typedFields) {
typedClass.getTypedFields().add((TypedField) field.convertToTypedAST(localVar, classes, unTypedAST));
}
for (TypedMethod method: typedMethods) {
typedClass.getTypedMethods().add((TypedMethod) method.convertToTypedAST(localVar, classes, unTypedAST));
}
return typedClass;
}

22
src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java
View File

@ -1,5 +1,8 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.Block;
import de.maishai.ast.records.Constructor;
import de.maishai.ast.records.Parameter;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
import lombok.Data;
@ -30,6 +33,23 @@ public class TypedConstructor implements Node {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Constructor untyped = (Constructor) unTypedAST;
TypedConstructor typedConstructor = new TypedConstructor();
typedConstructor.setTypedId((TypedId) typedId.convertToTypedAST(localVar, classes, untyped.id()));
if(untyped.params().isEmpty()) {
typedConstructor.setTypedParameters(null);
}else{
for(Parameter param : untyped.params()){
TypedParameter typedParam = new TypedParameter();
typedParam.convertToTypedAST(localVar, classes, param);
typedConstructor.getTypedParameters().add(typedParam);
}
}
Block block = untyped.block();
TypedBlock typedBlock = new TypedBlock();
typedBlock.convertToTypedAST(localVar, classes, block);
typedConstructor.setTypedBlock(typedBlock);
return typedConstructor;
}
}

3
src/main/java/de/maishai/typedast/typedclass/TypedContinue.java
View File

@ -1,5 +1,6 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.Continue;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
import de.maishai.typedast.Type;
@ -16,6 +17,6 @@ public class TypedContinue implements Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
return new TypedContinue();
}
}

9
src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java
View File

@ -1,5 +1,6 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.DoWhile;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
@ -22,6 +23,12 @@ public class TypedDoWhile implements Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
DoWhile untyped = (DoWhile) unTypedAST;
TypedDoWhile typedDoWhile = new TypedDoWhile();
typedDoWhile.setTypedBlock( (TypedBlock) typedBlock.convertToTypedAST(localVar, classes, untyped.block()));
typedDoWhile.setCond((Expression) cond.convertToTypedAST(localVar, classes, untyped.cond()));
return typedDoWhile;
}
}

9
src/main/java/de/maishai/typedast/typedclass/TypedField.java
View File

@ -1,7 +1,9 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.Field;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
import de.maishai.typedast.TypeMapper;
import lombok.Data;
import java.util.Map;
@ -22,7 +24,12 @@ public class TypedField implements Node {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Field untypedField = (Field) unTypedAST;
TypedField typedField = new TypedField();
typedField.setTypedId((TypedId) typedId.convertToTypedAST(localVar, classes, untypedField.name()));
typedField.setType(TypeMapper.getType(untypedField.type()));
return typedField;
}

9
src/main/java/de/maishai/typedast/typedclass/TypedFieldId.java
View File

@ -1,5 +1,6 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.FieldId;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
@ -23,6 +24,12 @@ public class TypedFieldId implements Node {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
FieldId untypedFieldId = (FieldId) unTypedAST;
TypedFieldId typedFieldId = new TypedFieldId();
typedFieldId.setField(untypedFieldId.field());
typedFieldId.setRecipient((Expression) recipient.convertToTypedAST(localVar, classes, untypedFieldId.recipient()));
typedFieldId.setTypedId((TypedId) typedId.convertToTypedAST(localVar, classes, untypedFieldId.id()));
return typedFieldId;
}
}

14
src/main/java/de/maishai/typedast/typedclass/TypedFor.java
View File

@ -1,14 +1,19 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.For;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
import de.maishai.typedast.Type;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TypedFor implements Statement {
private Expression assign;
private Expression cond;
@ -26,6 +31,13 @@ public class TypedFor implements Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
For untyped = (For) unTypedAST;
TypedFor typedFor = new TypedFor();
typedFor.setAssign((Expression) assign.convertToTypedAST(localVar, classes, untyped.assign()));
typedFor.setCond((Expression) cond.convertToTypedAST(localVar, classes, untyped.cond()));
typedFor.setInc((Expression) inc.convertToTypedAST(localVar, classes, untyped.inc()));
typedFor.setTypedBlock((TypedBlock) typedBlock.convertToTypedAST(localVar, classes, untyped.block()));
return typedFor;
}
}

6
src/main/java/de/maishai/typedast/typedclass/TypedId.java
View File

@ -1,13 +1,16 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.Id;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.Map;
@Data
@AllArgsConstructor
public class TypedId implements Expression {
private String name;
@ -22,6 +25,7 @@ public class TypedId implements Expression {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Id untypedId = (Id) unTypedAST;
return new TypedId(untypedId.name());
}
}

18
src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java
View File

@ -1,5 +1,6 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.IfElse;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
@ -10,18 +11,18 @@ import java.util.Map;
@Data
public class TypedIfElse implements Statement {
private Expression cond;
private Expression typedCon;
private TypedBlock ifTypedBlock;
private TypedBlock elseTypedBlock;
@Override
public Type typeCheck(Map<String, Type> localVar, Map<String, TypedClass> classes) {
// if(cond, Statement1, Statement2)
// condition must be a boolean
if(cond.typeCheck(localVar, classes) != Type.BOOL){
if (typedCon.typeCheck(localVar, classes) != Type.BOOL) {
throw new RuntimeException("If condition must be a boolean");
}
//Statement1 and Statement2 must be of type void
if(ifTypedBlock.typeCheck(localVar, classes) != Type.VOID){
if (ifTypedBlock.typeCheck(localVar, classes) != Type.VOID) {
throw new RuntimeException("If block must be of type void");
}
return Type.VOID;
@ -29,6 +30,13 @@ public class TypedIfElse implements Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
IfElse ifElse = (IfElse) unTypedAST;
TypedIfElse typedIfElse = new TypedIfElse();
typedIfElse.setTypedCon((Expression) typedCon.convertToTypedAST(localVar, classes, ifElse.cond()));
typedIfElse.setIfTypedBlock((TypedBlock) ifTypedBlock.convertToTypedAST(localVar, classes, ifElse.ifBlock()));
typedIfElse.setElseTypedBlock((TypedBlock) elseTypedBlock.convertToTypedAST(localVar, classes, ifElse.elseBlock()));
return typedIfElse;
}
}

8
src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java
View File

@ -1,13 +1,18 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.IntLiteral;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TypedIntLiteral implements Expression {
private Integer value;
@Override
@ -17,6 +22,7 @@ public class TypedIntLiteral implements Expression {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
IntLiteral untyped = (IntLiteral) unTypedAST;
return new TypedIntLiteral(untyped.value());
}
}

16
src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java
View File

@ -1,12 +1,18 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.LocalVariable;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
import de.maishai.typedast.TypeMapper;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
@Data
public class TypedLocalVariable implements Node {
@AllArgsConstructor
@NoArgsConstructor
public final class TypedLocalVariable implements Node {
private TypedId typedId;
private Type type;
@ -21,6 +27,12 @@ public class TypedLocalVariable implements Node {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
LocalVariable untypedLocalVariable = (LocalVariable) unTypedAST;
TypedLocalVariable typedLocalVariable = new TypedLocalVariable();
typedLocalVariable.setTypedId((TypedId) typedId.convertToTypedAST(localVar, classes, untypedLocalVariable.name()));
typedLocalVariable.setType(TypeMapper.getType(untypedLocalVariable.type()));
return typedLocalVariable;
}
}

11
src/main/java/de/maishai/typedast/typedclass/TypedMainMethod.java
View File

@ -1,12 +1,17 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.MainMethod;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TypedMainMethod implements Node {
private TypedBlock typedBlock;
@Override
@ -16,7 +21,11 @@ public class TypedMainMethod implements Node {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
MainMethod untyped = (MainMethod) unTypedAST;
TypedMainMethod typedMainMethod = new TypedMainMethod();
typedMainMethod.setTypedBlock((TypedBlock) typedBlock.convertToTypedAST(localVar, classes, untyped.block()));
return typedMainMethod;
}
}

41
src/main/java/de/maishai/typedast/typedclass/TypedMethod.java
View File

@ -1,7 +1,11 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.Block;
import de.maishai.ast.records.Method;
import de.maishai.ast.records.Parameter;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
import de.maishai.typedast.TypeMapper;
import lombok.Data;
import java.util.List;
@ -28,7 +32,42 @@ public class TypedMethod implements Node {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Method untypedMethod = (Method) unTypedAST;
TypedMethod typedMethod = new TypedMethod();
typedMethod.setTypedId((TypedId) typedId.convertToTypedAST(localVar, classes, untypedMethod.id()));
typedMethod.setReturnType(TypeMapper.getReturnType(untypedMethod.type()));
if(untypedMethod.params().isEmpty()){
//TODO: Implement this
}
for(Parameter parameter : untypedMethod.params()) {
TypedParameter typedParameter = getTypedParameter(parameter);
typedMethod.getTypedParameters().add(typedParameter);
}
TypedBlock typedBlock = new TypedBlock();
typedMethod.setTypedBlock((TypedBlock) typedBlock.convertToTypedAST(localVar, classes, untypedMethod.block()));
return typedMethod;
}
private TypedParameter getTypedParameter(Parameter parameter) {
TypedParameter typedParameter = new TypedParameter();
typedParameter.setTypedId(new TypedId(parameter.name()));
if(parameter.type() == de.maishai.ast.Type.CHAR){
typedParameter.setType(Type.CHAR);
}
if(parameter.type() == de.maishai.ast.Type.BOOL){
typedParameter.setType(Type.BOOL);
}
if(parameter.type() == de.maishai.ast.Type.INT){
typedParameter.setType(Type.INT);
}
return typedParameter;
}

1
src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java
View File

@ -24,6 +24,7 @@ public class TypedMethodCall implements Expression, Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
//TODO: Implement this
return null;
}
}

19
src/main/java/de/maishai/typedast/typedclass/TypedNew.java
View File

@ -1,9 +1,7 @@
package de.maishai.typedast.typedclass;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
import de.maishai.typedast.Type;
import de.maishai.ast.records.New;
import de.maishai.typedast.*;
import lombok.Data;
import java.util.List;
@ -36,6 +34,17 @@ public class TypedNew implements Expression, Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
New untyped = (New) unTypedAST;
TypedNew typedNew = new TypedNew();
typedNew.setType(TypeMapper.getType(untyped.type()));
if(untyped.args().isEmpty()){
//TODO: Implement this
}
for(de.maishai.ast.records.Expression arg : untyped.args()) {
//TODO: Implement this
}
return typedNew;
}
}

1
src/main/java/de/maishai/typedast/typedclass/TypedProgram.java
View File

@ -20,6 +20,7 @@ public class TypedProgram implements Node {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
//TODO: Implement this
return null;
}
}

6
src/main/java/de/maishai/typedast/typedclass/TypedReturn.java
View File

@ -1,6 +1,7 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.Return;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
@ -19,6 +20,9 @@ public class TypedReturn implements Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Return untyped = (Return) unTypedAST;
TypedReturn typedReturn = new TypedReturn();
typedReturn.setRet((Expression) ret.convertToTypedAST(localVar, classes, untyped.ret()));
return typedReturn;
}
}

7
src/main/java/de/maishai/typedast/typedclass/TypedReturnVoid.java
View File

@ -1,5 +1,6 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.Method;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
import de.maishai.typedast.Type;
@ -16,6 +17,10 @@ public class TypedReturnVoid implements Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Method untyped = (Method) unTypedAST;
if(untyped.type() != de.maishai.ast.ReturnType.VOID){
throw new RuntimeException("Return type is not void");
}
return new TypedReturnVoid();
}
}

7
src/main/java/de/maishai/typedast/typedclass/TypedUnary.java
View File

@ -1,6 +1,7 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.UnaryOperator;
import de.maishai.ast.records.Unary;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Type;
@ -32,6 +33,10 @@ public class TypedUnary implements Expression {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
Unary untyped = (Unary) unTypedAST;
TypedUnary typedUnary = new TypedUnary();
typedUnary.setOp(untyped.op());
typedUnary.setRight((Expression) right.convertToTypedAST(localVar, classes, untyped.right()));
return typedUnary;
}
}

7
src/main/java/de/maishai/typedast/typedclass/TypedWhile.java
View File

@ -1,5 +1,6 @@
package de.maishai.typedast.typedclass;
import de.maishai.ast.records.While;
import de.maishai.typedast.Expression;
import de.maishai.typedast.Node;
import de.maishai.typedast.Statement;
@ -22,6 +23,10 @@ public class TypedWhile implements Statement {
@Override
public Node convertToTypedAST(Map<String, Type> localVar, Map<String, TypedClass> classes, de.maishai.ast.records.Node unTypedAST) {
return null;
While untyped = (While) unTypedAST;
TypedWhile typedWhile = new TypedWhile();
typedWhile.setCond((Expression) cond.convertToTypedAST(localVar, classes, untyped.cond()));
typedWhile.setTypedBlock((TypedBlock) typedBlock.convertToTypedAST(localVar, classes, untyped.block()));
return typedWhile;
}
}