diff --git a/src/main/java/de/maishai/typedast/TypeMapper.java b/src/main/java/de/maishai/typedast/TypeMapper.java new file mode 100644 index 0000000..35a0227 --- /dev/null +++ b/src/main/java/de/maishai/typedast/TypeMapper.java @@ -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"); + } + +} \ No newline at end of file diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java index f42e35c..89ff8f4 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java @@ -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 localVar, Map 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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java b/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java index 6548ec9..88ffcc4 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java @@ -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 localVar, Map 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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java index 25b9c9d..020ede8 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java index c0e7b54..9fd454c 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java @@ -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 localVar, Map 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; diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java b/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java index 3f48365..39db88a 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java @@ -15,6 +15,6 @@ public class TypedBreak implements Statement { @Override public Node convertToTypedAST(Map localVar, Map classes, de.maishai.ast.records.Node unTypedAST) { - return null; + return new TypedBreak(); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java index d370ae7..c9e52c3 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java @@ -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 localVar, Map classes, de.maishai.ast.records.Node unTypedAST) { - return null; + CharLiteral untyped = (CharLiteral) unTypedAST; + TypedCharLiteral typedCharLiteral = new TypedCharLiteral(); + typedCharLiteral.setValue(untyped.value()); + return typedCharLiteral; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java index 7b5ad66..9ee61c5 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java @@ -19,6 +19,7 @@ public class TypedClass implements Node { @Override public Type typeCheck(Map localVar, Map 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; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java index 3914358..317163c 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedContinue.java b/src/main/java/de/maishai/typedast/typedclass/TypedContinue.java index 62e9a7c..85cde82 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedContinue.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedContinue.java @@ -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 localVar, Map classes, de.maishai.ast.records.Node unTypedAST) { - return null; + return new TypedContinue(); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java b/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java index a3d908f..4bfdca8 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedField.java b/src/main/java/de/maishai/typedast/typedclass/TypedField.java index cd238dc..6b2f499 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedField.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedField.java @@ -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 localVar, Map 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; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFieldId.java b/src/main/java/de/maishai/typedast/typedclass/TypedFieldId.java index 685f6cb..e9402d2 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFieldId.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFieldId.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFor.java b/src/main/java/de/maishai/typedast/typedclass/TypedFor.java index afb852a..64ed1e7 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFor.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedId.java b/src/main/java/de/maishai/typedast/typedclass/TypedId.java index 0fa3d9a..6618a76 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedId.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedId.java @@ -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 localVar, Map classes, de.maishai.ast.records.Node unTypedAST) { - return null; + Id untypedId = (Id) unTypedAST; + return new TypedId(untypedId.name()); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java b/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java index bbf59e4..627f1cf 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java @@ -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 localVar, Map 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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java index a5a4307..a499b5c 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java @@ -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 localVar, Map classes, de.maishai.ast.records.Node unTypedAST) { - return null; + IntLiteral untyped = (IntLiteral) unTypedAST; + return new TypedIntLiteral(untyped.value()); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java b/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java index 32c4c41..766236e 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMainMethod.java b/src/main/java/de/maishai/typedast/typedclass/TypedMainMethod.java index 74c21b3..aff86ac 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMainMethod.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMainMethod.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java index 7761285..ec5a90c 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java @@ -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 localVar, Map 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; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java index 5d07de0..9f5f81e 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java @@ -24,6 +24,7 @@ public class TypedMethodCall implements Expression, Statement { @Override public Node convertToTypedAST(Map localVar, Map classes, de.maishai.ast.records.Node unTypedAST) { + //TODO: Implement this return null; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedNew.java b/src/main/java/de/maishai/typedast/typedclass/TypedNew.java index 651f707..0e0d8f7 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedNew.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedNew.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedProgram.java b/src/main/java/de/maishai/typedast/typedclass/TypedProgram.java index fe3516e..cf80adf 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedProgram.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedProgram.java @@ -20,6 +20,7 @@ public class TypedProgram implements Node { @Override public Node convertToTypedAST(Map localVar, Map classes, de.maishai.ast.records.Node unTypedAST) { + //TODO: Implement this return null; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java b/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java index 60edd27..3f037e7 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedReturnVoid.java b/src/main/java/de/maishai/typedast/typedclass/TypedReturnVoid.java index 95a96b0..8e1ab9c 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedReturnVoid.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedReturnVoid.java @@ -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 localVar, Map 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(); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java b/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java index 03b2a0f..0311861 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java @@ -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 localVar, Map 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; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java b/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java index 3bceb8a..22ec0e6 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java @@ -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 localVar, Map 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; } }