diff --git a/src/de/dhbwstuttgart/core/JavaTXCompiler.java b/src/de/dhbwstuttgart/core/JavaTXCompiler.java index dc9a1127..cb39277d 100644 --- a/src/de/dhbwstuttgart/core/JavaTXCompiler.java +++ b/src/de/dhbwstuttgart/core/JavaTXCompiler.java @@ -27,7 +27,7 @@ import java.util.*; public class JavaTXCompiler { - private List sourceFiles = new ArrayList<>(); + protected List sourceFiles = new ArrayList<>(); public List getTypeInserts(File forFile){ ResultSet result = typeInference(); diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java index f69ec781..58eb92de 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java @@ -4,8 +4,6 @@ import de.dhbwstuttgart.exceptions.NotImplementedException; import de.dhbwstuttgart.parser.NullToken; import de.dhbwstuttgart.parser.antlr.Java8Parser; import de.dhbwstuttgart.syntaxtree.*; -import de.dhbwstuttgart.syntaxtree.operator.AndOp; -import de.dhbwstuttgart.syntaxtree.operator.OrOp; import de.dhbwstuttgart.syntaxtree.statement.*; import de.dhbwstuttgart.syntaxtree.statement.literal.*; import de.dhbwstuttgart.syntaxtree.type.RefType; @@ -505,7 +503,7 @@ public class StatementGenerator { return convert(expression.conditionalAndExpression()); }else{ return new Binary(convert(expression.conditionalOrExpression()), - convert(expression.conditionalAndExpression()), new OrOp(null)); + convert(expression.conditionalAndExpression()), Binary.Operator.OR); } } @@ -514,7 +512,7 @@ public class StatementGenerator { return convert(expression.inclusiveOrExpression()); }else{ return new Binary(convert(expression.conditionalAndExpression()), - convert(expression.inclusiveOrExpression()), new AndOp(null)); + convert(expression.inclusiveOrExpression()), Binary.Operator.AND); } } @@ -821,7 +819,7 @@ public class StatementGenerator { funNParams.add(TypePlaceholder.fresh(expression.getStart()))); RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart()); //RefType lambdaType = new RefType(reg.getName("Fun"+params.getFormalparalist().size()), - //funNParams, expression.getStart()); + //funNParams, name.getStart()); return new LambdaExpression(lambdaType, params, block, expression.getStart()); } } diff --git a/src/de/dhbwstuttgart/parser/antlr/Java8Parser.java b/src/de/dhbwstuttgart/parser/antlr/Java8Parser.java index 851e7ead..1af14046 100644 --- a/src/de/dhbwstuttgart/parser/antlr/Java8Parser.java +++ b/src/de/dhbwstuttgart/parser/antlr/Java8Parser.java @@ -180,7 +180,7 @@ public class Java8Parser extends Parser { "methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList", "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", "arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", - "expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", + "name", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", "lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", "conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", "inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", diff --git a/src/de/dhbwstuttgart/syntaxtree/ASTVisitor.java b/src/de/dhbwstuttgart/syntaxtree/ASTVisitor.java new file mode 100644 index 00000000..d7527634 --- /dev/null +++ b/src/de/dhbwstuttgart/syntaxtree/ASTVisitor.java @@ -0,0 +1,37 @@ +package de.dhbwstuttgart.syntaxtree; + +import de.dhbwstuttgart.syntaxtree.statement.*; +import de.dhbwstuttgart.syntaxtree.statement.literal.Literal; +import de.dhbwstuttgart.syntaxtree.statement.literal.Null; +import de.dhbwstuttgart.syntaxtree.type.*; + +public interface ASTVisitor extends StatementVisitor{ + + void visit(SourceFile sourceFile); + + void visit(ArgumentList argumentList); + + void visit(GenericTypeVar genericTypeVar); + + void visit(FormalParameter formalParameter); + + void visit(GenericDeclarationList genericTypeVars); + + void visit(Field field); + + void visit(Method field); + + void visit(ParameterList formalParameters); + + void visit(ClassOrInterface classOrInterface); + + void visit(RefType refType); + + void visit(SuperWildcardType superWildcardType); + + void visit(TypePlaceholder typePlaceholder); + + void visit(ExtendsWildcardType extendsWildcardType); + + void visit(GenericRefType genericRefType); +} diff --git a/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java b/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java new file mode 100644 index 00000000..12696edc --- /dev/null +++ b/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java @@ -0,0 +1,145 @@ +package de.dhbwstuttgart.syntaxtree; + +import de.dhbwstuttgart.syntaxtree.statement.*; +import de.dhbwstuttgart.syntaxtree.statement.literal.Literal; +import de.dhbwstuttgart.syntaxtree.statement.literal.Null; +import de.dhbwstuttgart.syntaxtree.type.*; + +import java.lang.reflect.Modifier; +import java.util.Iterator; + +public abstract class AbstractASTWalker implements ASTVisitor{ + + @Override + public void visit(SourceFile sourceFile) { + for(ClassOrInterface cl : sourceFile.getClasses()){ + cl.accept(this); + } + } + + @Override + public void visit(ArgumentList argumentList) { + for(Expression expr : argumentList.getArguments()){ + expr.accept(this); + } + } + + @Override + public void visit(FormalParameter formalParameter) { + formalParameter.getType().accept(this); + } + + @Override + public void visit(GenericDeclarationList genericTypeVars) { + Iterator genericIterator = genericTypeVars.iterator(); + if(genericIterator.hasNext()){ + while(genericIterator.hasNext()){ + genericIterator.next().accept(this); + } + } + } + + @Override + public void visit(Field field) { + field.getType().accept(this); + } + + @Override + public void visit(Method method) { + method.getType().accept(this); + method.getParameterList().accept(this); + method.block.accept(this); + } + + @Override + public void visit(ParameterList formalParameters) { + Iterator genericIterator = formalParameters.getFormalparalist().iterator(); + if(genericIterator.hasNext()){ + while(genericIterator.hasNext()){ + genericIterator.next().accept(this); + } + } + } + + @Override + public void visit(ClassOrInterface classOrInterface) { + classOrInterface.getGenerics().accept(this); + for(Field f : classOrInterface.getFieldDecl()){ + f.accept(this); + } + for(Method m : classOrInterface.getMethods()){ + m.accept(this); + } + } + + @Override + public void visit(RefType refType) { + Iterator genericIterator = refType.getParaList().iterator(); + if(genericIterator.hasNext()){ + while(genericIterator.hasNext()){ + genericIterator.next().accept(this); + } + } + } + + @Override + public void visit(SuperWildcardType superWildcardType) { + superWildcardType.getInnerType().accept(this); + } + + @Override + public void visit(ExtendsWildcardType extendsWildcardType) { + extendsWildcardType.getInnerType().accept(this); + } + + @Override + public void visit(LambdaExpression lambdaExpression) { + lambdaExpression.params.accept(this); + lambdaExpression.methodBody.accept(this); + } + + @Override + public void visit(Assign assign) { + assign.lefSide.accept(this); + assign.rightSide.accept(this); + } + + @Override + public void visit(Block block) { + for(Statement stmt : block.getStatements()){ + stmt.accept(this); + } + } + + @Override + public void visit(FieldVar fieldVar) { + fieldVar.receiver.accept(this); + } + + + @Override + public void visit(LocalVarDecl localVarDecl) { + localVarDecl.getType().accept(this); + } + + @Override + public void visit(MethodCall methodCall) { + methodCall.receiver.accept(this); + methodCall.getArgumentList().accept(this); + } + + @Override + public void visit(NewClass methodCall) { + visit((MethodCall) methodCall); + } + + @Override + public void visit(Receiver receiver) { + receiver.expr.accept(this); + } + + @Override + public void visit(Return aReturn) { + aReturn.retexpr.accept(this); + } +} diff --git a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java index 79098e4d..1604c8c5 100755 --- a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java +++ b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java @@ -2,6 +2,7 @@ package de.dhbwstuttgart.syntaxtree; import de.dhbwstuttgart.core.IItemWithOffset; import de.dhbwstuttgart.syntaxtree.type.RefType; +import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter; import de.dhbwstuttgart.typecheck.JavaClassName; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; import de.dhbwstuttgart.typeinference.constraints.Constraint; @@ -15,13 +16,12 @@ import java.util.List; /** * Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces */ -public class ClassOrInterface implements IItemWithOffset{ +public class ClassOrInterface extends SyntaxTreeNode { protected int modifiers; protected JavaClassName name; private List fields = new ArrayList<>(); private List methods = new ArrayList<>(); private GenericDeclarationList genericClassParameters; - private Token offset; private RefTypeOrTPHOrWildcardOrGeneric superClass; protected boolean isInterface; private List implementedInterfaces; @@ -29,12 +29,11 @@ public class ClassOrInterface implements IItemWithOffset{ public ClassOrInterface(int modifiers, JavaClassName name, List fielddecl, List methods, List constructors, GenericDeclarationList genericClassParameters, RefTypeOrTPHOrWildcardOrGeneric superClass, Boolean isInterface, List implementedInterfaces, Token offset){ - this.offset = offset; + super(offset); this.modifiers = modifiers; this.name = name; this.fields = fielddecl; this.genericClassParameters = genericClassParameters; - this.offset = offset; this.superClass = superClass; this.isInterface = isInterface; this.implementedInterfaces = implementedInterfaces; @@ -88,7 +87,7 @@ public class ClassOrInterface implements IItemWithOffset{ } @Override - public Token getOffset() { - return offset; + public void accept(ASTVisitor visitor) { + visitor.visit(this); } } diff --git a/src/de/dhbwstuttgart/syntaxtree/Field.java b/src/de/dhbwstuttgart/syntaxtree/Field.java index 4961443c..82c3053f 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Field.java +++ b/src/de/dhbwstuttgart/syntaxtree/Field.java @@ -24,5 +24,10 @@ public class Field extends SyntaxTreeNode{ public RefTypeOrTPHOrWildcardOrGeneric getType() { return type; } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java b/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java index 7fb16d83..8e7e7983 100755 --- a/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java +++ b/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java @@ -21,4 +21,9 @@ public class FormalParameter extends SyntaxTreeNode public String getName() { return name; } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java b/src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java index ceea42b1..e316aa6b 100644 --- a/src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java +++ b/src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java @@ -26,4 +26,9 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable iterator() { return gtvs.iterator(); } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java index 5d151046..8ac65e35 100755 --- a/src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java @@ -51,4 +51,9 @@ public class GenericTypeVar extends SyntaxTreeNode public GenericTypeName getName() { return name; } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/Method.java b/src/de/dhbwstuttgart/syntaxtree/Method.java index 350d8b15..065945ee 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Method.java +++ b/src/de/dhbwstuttgart/syntaxtree/Method.java @@ -23,7 +23,7 @@ import de.dhbwstuttgart.syntaxtree.statement.Block; */ public class Method extends Field implements IItemWithOffset, TypeScope { - private Block block; + public final Block block; private ParameterList parameterlist = new ParameterList(new ArrayList<>(), new NullToken()); private ExceptionList exceptionlist; private GenericDeclarationList generics; @@ -56,4 +56,9 @@ public class Method extends Field implements IItemWithOffset, TypeScope public RefTypeOrTPHOrWildcardOrGeneric getReturnType() { return this.getType(); } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/ParameterList.java b/src/de/dhbwstuttgart/syntaxtree/ParameterList.java index b7d6860f..2540f907 100755 --- a/src/de/dhbwstuttgart/syntaxtree/ParameterList.java +++ b/src/de/dhbwstuttgart/syntaxtree/ParameterList.java @@ -32,6 +32,11 @@ public class ParameterList extends SyntaxTreeNode implements Iterable iterator() { - return null; + return formalparameter.iterator(); } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java index 2dda4b29..c18385ad 100755 --- a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java +++ b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java @@ -62,4 +62,9 @@ public class SourceFile extends SyntaxTreeNode{ public File getFile() { return file; } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/StatementVisitor.java b/src/de/dhbwstuttgart/syntaxtree/StatementVisitor.java index eddaeece..39db3ef0 100644 --- a/src/de/dhbwstuttgart/syntaxtree/StatementVisitor.java +++ b/src/de/dhbwstuttgart/syntaxtree/StatementVisitor.java @@ -27,8 +27,6 @@ public interface StatementVisitor { void visit(InstanceOf instanceOf); - void visit(InstVar instVar); - void visit(LocalVar localVar); void visit(LocalVarDecl localVarDecl); diff --git a/src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java b/src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java index 58155562..77e26be8 100644 --- a/src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java +++ b/src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java @@ -19,4 +19,5 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{ return offset; } + public abstract void accept(ASTVisitor visitor); } diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java deleted file mode 100755 index 00eb55ba..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java +++ /dev/null @@ -1,23 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; -import java.util.HashMap; -import java.util.Hashtable; -import java.util.Iterator; - -import org.antlr.v4.runtime.Token; -import org.apache.bcel.Constants; -import org.apache.bcel.generic.ArithmeticInstruction; -import org.apache.bcel.generic.DUP; -import org.apache.bcel.generic.IADD; -import org.apache.bcel.generic.InstructionList; -import org.apache.bcel.generic.InvokeInstruction; -import org.apache.bcel.generic.ObjectType; - - - -public abstract class AddOp extends Operator -{ - public AddOp(Token offset) { - super(offset); - } - -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/AndOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/AndOp.java deleted file mode 100755 index 945bd0b6..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/AndOp.java +++ /dev/null @@ -1,18 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; -import de.dhbwstuttgart.syntaxtree.statement.Binary; -import org.antlr.v4.runtime.Token; -import org.apache.bcel.generic.InstructionList; - -public class AndOp extends LogOp -{ - - public AndOp(Token offset) - { - super(offset); - } - - - -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java deleted file mode 100755 index 6b6bdccf..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java +++ /dev/null @@ -1,12 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - - - -public class DivideOp extends MulOp -{ - public DivideOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java deleted file mode 100755 index 6b733dd7..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java +++ /dev/null @@ -1,15 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; -import org.apache.bcel.generic.BranchInstruction; -import org.apache.bcel.generic.IF_ICMPNE; - - -public class EqualOp extends RelOp -{ - - - public EqualOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java deleted file mode 100755 index a90a8bcf..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java +++ /dev/null @@ -1,13 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - - - -public class GreaterEquOp extends RelOp -{ - - public GreaterEquOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java deleted file mode 100755 index 08dfd37c..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java +++ /dev/null @@ -1,14 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; -import org.antlr.v4.runtime.Token; - - - - -public class GreaterOp extends RelOp -{ - - - public GreaterOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java deleted file mode 100755 index cbff126e..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java +++ /dev/null @@ -1,15 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - - - - -public class LessEquOp extends RelOp -{ - - - public LessEquOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java deleted file mode 100755 index 8be12e11..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java +++ /dev/null @@ -1,14 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; -import org.antlr.v4.runtime.Token; - - - - -public class LessOp extends RelOp -{ - public LessOp(Token offset) - { - super(offset); - } - -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java deleted file mode 100755 index 69df6267..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java +++ /dev/null @@ -1,18 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; -import org.antlr.v4.runtime.Token; - -import java.util.HashMap; -import java.util.Hashtable; -import java.util.Iterator; - - - -public abstract class LogOp extends Operator -{ - - public LogOp(Token offset) - { - super(offset); - } - -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java deleted file mode 100755 index 32b69c66..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java +++ /dev/null @@ -1,11 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - - -import org.antlr.v4.runtime.Token; - -public class MinusOp extends AddOp -{ - public MinusOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java deleted file mode 100755 index c33d0e1d..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java +++ /dev/null @@ -1,15 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - - - - -public class ModuloOp extends MulOp -{ - public ModuloOp(Token offset) - { - super(offset); - } - -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java deleted file mode 100755 index 484393c2..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java +++ /dev/null @@ -1,10 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - -public abstract class MulOp extends Operator -{ - public MulOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java deleted file mode 100755 index 60a809ae..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java +++ /dev/null @@ -1,11 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - -public class NotEqualOp extends RelOp -{ - - public NotEqualOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/Operator.java b/src/de/dhbwstuttgart/syntaxtree/operator/Operator.java deleted file mode 100755 index 23e8299f..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/Operator.java +++ /dev/null @@ -1,13 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - - -import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; -import org.antlr.v4.runtime.Token; - -public abstract class Operator extends SyntaxTreeNode -{ - - public Operator(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/OrOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/OrOp.java deleted file mode 100755 index 856be57d..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/OrOp.java +++ /dev/null @@ -1,15 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - - -public class OrOp extends LogOp -{ - - public OrOp(Token offset) - { - super(offset); - } - - -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java deleted file mode 100755 index 7d83836f..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java +++ /dev/null @@ -1,12 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - - -import org.antlr.v4.runtime.Token; - -public class PlusOp extends AddOp -{ - public PlusOp(Token offset) - { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java deleted file mode 100755 index 2ff001a4..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java +++ /dev/null @@ -1,11 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - -public abstract class RelOp extends Operator -{ - - public RelOp(Token offset) { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java deleted file mode 100755 index 421b03f6..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java +++ /dev/null @@ -1,11 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.operator; - -import org.antlr.v4.runtime.Token; - -public class TimesOp extends MulOp -{ - public TimesOp(Token offset) - { - super(offset); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java b/src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java index 87bf459c..75c92370 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java @@ -1,6 +1,7 @@ package de.dhbwstuttgart.syntaxtree.statement; +import de.dhbwstuttgart.syntaxtree.ASTVisitor; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import org.antlr.v4.runtime.Token; @@ -19,4 +20,8 @@ public class ArgumentList extends SyntaxTreeNode return expr; } + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Binary.java b/src/de/dhbwstuttgart/syntaxtree/statement/Binary.java index 321509f9..8a0a0b35 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Binary.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Binary.java @@ -6,12 +6,16 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation; import de.dhbwstuttgart.typeinference.constraints.ConstraintSet; import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation; -import de.dhbwstuttgart.syntaxtree.operator.Operator; - // neu von Felix public class Binary extends Expression { + public enum Operator{ + ADD, + SUB, + MUL, + AND, OR, DIV + } public Binary(Expression expr1, Expression expr2, Operator op){ super(null, null); } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Expression.java b/src/de/dhbwstuttgart/syntaxtree/statement/Expression.java index 9a59db84..d3c70e76 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Expression.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Expression.java @@ -1,6 +1,7 @@ package de.dhbwstuttgart.syntaxtree.statement; +import de.dhbwstuttgart.syntaxtree.ASTVisitor; import de.dhbwstuttgart.syntaxtree.StatementVisitor; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; @@ -24,5 +25,11 @@ public abstract class Expression extends SyntaxTreeNode public abstract void accept(StatementVisitor visitor); + + @Override + public void accept(ASTVisitor visitor) { + this.accept((StatementVisitor)visitor); + } + public String toString() { return this.getClass().getName() + ":" + type.toString(); } } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java b/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java deleted file mode 100755 index 021b5039..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java +++ /dev/null @@ -1,24 +0,0 @@ -package de.dhbwstuttgart.syntaxtree.statement; - -import de.dhbwstuttgart.exceptions.NotImplementedException; -import de.dhbwstuttgart.syntaxtree.StatementVisitor; -import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation; -import de.dhbwstuttgart.typeinference.constraints.ConstraintSet; -import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation; -import org.antlr.v4.runtime.Token; - - -public class InstVar extends Expression -{ - private Expression expr; - public InstVar(Expression instanz, String name, Token offset) - { - super(instanz.getType(),offset); - expr = instanz; - } - - @Override - public void accept(StatementVisitor visitor) { - visitor.visit(this); - } -} diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LocalVar.java b/src/de/dhbwstuttgart/syntaxtree/statement/LocalVar.java index 3c703a6f..91094a7a 100644 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LocalVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/LocalVar.java @@ -1,28 +1,23 @@ package de.dhbwstuttgart.syntaxtree.statement; -import de.dhbwstuttgart.exceptions.NotImplementedException; import de.dhbwstuttgart.syntaxtree.StatementVisitor; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; -import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; -import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation; -import de.dhbwstuttgart.typeinference.constraints.ConstraintSet; -import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation; import org.antlr.v4.runtime.Token; public class LocalVar extends Statement{ - protected final String expression; + public final String name; public LocalVar(String n, RefTypeOrTPHOrWildcardOrGeneric type, Token offset) { super(type,offset); - this.expression = n; + this.name = n; } public LocalVar(Expression e1, RefTypeOrTPHOrWildcardOrGeneric type, String access) { super(type,e1.getOffset()); - this.expression = access; + this.name = access; } @Override diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java b/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java index 911fd056..b6f2a795 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java @@ -31,7 +31,7 @@ public class NewClass extends MethodCall * @param start */ public NewClass(RefType newClass, ArgumentList args, Token start) { - super(newClass, new Receiver(new EmptyStmt(start)), "new "+newClass.getName().toString(), args, start); + super(newClass, new Receiver(new EmptyStmt(start)), newClass.getName().toString(), args, start); } @Override diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/This.java b/src/de/dhbwstuttgart/syntaxtree/statement/This.java index f3084777..81899052 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/This.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/This.java @@ -1,7 +1,6 @@ package de.dhbwstuttgart.syntaxtree.statement; import de.dhbwstuttgart.syntaxtree.StatementVisitor; -import de.dhbwstuttgart.syntaxtree.operator.Operator; import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation; diff --git a/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java index ecbc79d7..0767c59d 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java @@ -1,6 +1,7 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.ASTVisitor; import org.antlr.v4.runtime.Token; /** @@ -33,4 +34,8 @@ public class ExtendsWildcardType extends WildcardType{ } + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java b/src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java index 8a50c726..ebb28946 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.ASTVisitor; import de.dhbwstuttgart.typecheck.GenericTypeName; import de.dhbwstuttgart.typecheck.JavaClassName; import org.antlr.v4.runtime.Token; @@ -20,5 +21,10 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric public String getUniqueIdentifier(){ return name.toString(); } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java index bd370c3f..e8030403 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.ASTVisitor; import de.dhbwstuttgart.typecheck.JavaClassName; import org.antlr.v4.runtime.Token; @@ -100,5 +101,9 @@ public class RefType extends RefTypeOrTPHOrWildcardOrGeneric } + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/RefTypeOrTPHOrWildcardOrGeneric.java b/src/de/dhbwstuttgart/syntaxtree/type/RefTypeOrTPHOrWildcardOrGeneric.java index 79813f56..20bc5b45 100644 --- a/src/de/dhbwstuttgart/syntaxtree/type/RefTypeOrTPHOrWildcardOrGeneric.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/RefTypeOrTPHOrWildcardOrGeneric.java @@ -1,10 +1,14 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.ASTVisitor; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import org.antlr.v4.runtime.Token; -public class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{ +public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{ public RefTypeOrTPHOrWildcardOrGeneric(Token offset) { super(offset); } + + @Override + public abstract void accept(ASTVisitor visitor); } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java index babc0a31..4cbee79e 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java @@ -1,6 +1,7 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.ASTVisitor; import org.antlr.v4.runtime.Token; /** @@ -42,4 +43,9 @@ public class SuperWildcardType extends WildcardType{ public boolean isSuper() { return true; } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java b/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java index 82f7e298..97845545 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java @@ -1,6 +1,7 @@ package de.dhbwstuttgart.syntaxtree.type; import java.util.Hashtable; +import de.dhbwstuttgart.syntaxtree.ASTVisitor; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.factory.NameGenerator; import org.antlr.v4.runtime.Token; @@ -65,4 +66,9 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric public String getName() { return name; } + + @Override + public void accept(ASTVisitor visitor) { + visitor.visit(this); + } } diff --git a/src/de/dhbwstuttgart/syntaxtree/visual/ASTPrinter.java b/src/de/dhbwstuttgart/syntaxtree/visual/ASTPrinter.java new file mode 100644 index 00000000..9d04b298 --- /dev/null +++ b/src/de/dhbwstuttgart/syntaxtree/visual/ASTPrinter.java @@ -0,0 +1,13 @@ +package de.dhbwstuttgart.syntaxtree.visual; + +import de.dhbwstuttgart.syntaxtree.*; + +public class ASTPrinter { + + public static String print(SourceFile toPrint){ + StringBuilder output = new StringBuilder(); + new OutputGenerator(output).visit(toPrint); + return output.toString(); + } + +} diff --git a/src/de/dhbwstuttgart/syntaxtree/visual/ASTTypePrinter.java b/src/de/dhbwstuttgart/syntaxtree/visual/ASTTypePrinter.java new file mode 100644 index 00000000..2dc7ae54 --- /dev/null +++ b/src/de/dhbwstuttgart/syntaxtree/visual/ASTTypePrinter.java @@ -0,0 +1,20 @@ +package de.dhbwstuttgart.syntaxtree.visual; + +import de.dhbwstuttgart.syntaxtree.*; +import de.dhbwstuttgart.syntaxtree.statement.*; +import de.dhbwstuttgart.syntaxtree.statement.literal.Literal; +import de.dhbwstuttgart.syntaxtree.statement.literal.Null; +import de.dhbwstuttgart.syntaxtree.type.*; + +import java.lang.reflect.Modifier; +import java.util.Iterator; + +public class ASTTypePrinter extends ASTPrinter{ + + public static String print(SourceFile toPrint){ + StringBuilder output = new StringBuilder(); + new TypeOutputGenerator(output).visit(toPrint); + return output.toString(); + } + +} diff --git a/src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java b/src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java new file mode 100644 index 00000000..637a5ef5 --- /dev/null +++ b/src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java @@ -0,0 +1,307 @@ +package de.dhbwstuttgart.syntaxtree.visual; + +import de.dhbwstuttgart.syntaxtree.*; +import de.dhbwstuttgart.syntaxtree.statement.*; +import de.dhbwstuttgart.syntaxtree.statement.literal.Literal; +import de.dhbwstuttgart.syntaxtree.statement.literal.Null; +import de.dhbwstuttgart.syntaxtree.type.*; + +import java.lang.reflect.Modifier; +import java.util.Iterator; + +public class OutputGenerator implements ASTVisitor { + private static final String TAB = " "; + String tabs = ""; + protected final StringBuilder out; + + public OutputGenerator(StringBuilder out){ + this.out = out; + } + + public void tab() { + tabs += TAB; + } + + public void untab() { + tabs = tabs.substring(0,tabs.length()-TAB.length()); + } + + @Override + public void visit(SourceFile sourceFile) { + for(ClassOrInterface cl : sourceFile.getClasses()){ + cl.accept(this); + } + } + + @Override + public void visit(ArgumentList argumentList) { + out.append("("); + Iterator expressionIterator = argumentList.getArguments().iterator(); + while(expressionIterator.hasNext()){ + expressionIterator.next().accept(this); + if(expressionIterator.hasNext())out.append(", "); + } + out.append(")"); + } + + @Override + public void visit(GenericTypeVar genericTypeVar) { + out.append(genericTypeVar.getName().toString()); + } + + @Override + public void visit(FormalParameter formalParameter) { + formalParameter.getType().accept(this); + out.append(" "); + out.append(formalParameter.getName()); + } + + @Override + public void visit(GenericDeclarationList genericTypeVars) { + Iterator genericIterator = genericTypeVars.iterator(); + if(genericIterator.hasNext()){ + out.append("<"); + while(genericIterator.hasNext()){ + genericIterator.next().accept(this); + if(genericIterator.hasNext())out.append(", "); + } + out.append(">"); + } + } + + @Override + public void visit(Field field) { + field.getType().accept(this); + out.append(" "); + out.append(field.getName()); + out.append(";"); + } + + @Override + public void visit(Method method) { + method.getType().accept(this); + out.append(" " + method.getName()); + method.getParameterList().accept(this); + method.block.accept(this); + out.append("\n"); + } + + @Override + public void visit(ParameterList formalParameters) { + out.append("("); + Iterator genericIterator = formalParameters.getFormalparalist().iterator(); + if(genericIterator.hasNext()){ + while(genericIterator.hasNext()){ + genericIterator.next().accept(this); + if(genericIterator.hasNext())out.append(", "); + } + } + out.append(")"); + } + + @Override + public void visit(ClassOrInterface classOrInterface) { + if((Modifier.INTERFACE & classOrInterface.getModifiers()) == 1){ + out.append("interface "); + }else{ + out.append("class "); + } + out.append(classOrInterface.getClassName().toString()); + classOrInterface.getGenerics().accept(this); + out.append(" {\n\n"); + tab(); + for(Field f : classOrInterface.getFieldDecl()){ + out.append(tabs); + f.accept(this); + out.append("\n"); + } + for(Method m : classOrInterface.getMethods()){ + out.append(tabs); + m.accept(this); + out.append("\n"); + } + untab(); + out.append("}"); + } + + @Override + public void visit(RefType refType) { + out.append(refType.getName().toString()); + Iterator genericIterator = refType.getParaList().iterator(); + if(genericIterator.hasNext()){ + out.append("<"); + while(genericIterator.hasNext()){ + genericIterator.next().accept(this); + if(genericIterator.hasNext())out.append(", "); + } + out.append(">"); + } + } + + @Override + public void visit(SuperWildcardType superWildcardType) { + out.append("? super "); + superWildcardType.getInnerType().accept(this); + } + + @Override + public void visit(TypePlaceholder typePlaceholder) { + out.append("TPH "+ typePlaceholder.getName()); + } + + @Override + public void visit(ExtendsWildcardType extendsWildcardType) { + out.append("? extends "); + extendsWildcardType.getInnerType().accept(this); + } + + @Override + public void visit(GenericRefType genericRefType) { + out.append(genericRefType.getName().toString()); + } + + @Override + public void visit(LambdaExpression lambdaExpression) { + lambdaExpression.params.accept(this); + out.append(" -> "); + lambdaExpression.methodBody.accept(this); + } + + @Override + public void visit(Assign assign) { + assign.lefSide.accept(this); + out.append(" = "); + assign.rightSide.accept(this); + } + + @Override + public void visit(Binary binary) { + + } + + @Override + public void visit(Block block) { + tab(); + out.append("{\n"); + for(Statement stmt : block.getStatements()){ + out.append(tabs); + stmt.accept(this); + out.append(";\n"); + } + untab(); + out.append(tabs); + out.append("}"); + } + + @Override + public void visit(CastExpr castExpr) { + + } + + @Override + public void visit(EmptyStmt emptyStmt) { + + } + + @Override + public void visit(FieldVar fieldVar) { + fieldVar.receiver.accept(this); + out.append("." + fieldVar.fieldVarName); + } + + @Override + public void visit(ForStmt forStmt) { + + } + + @Override + public void visit(IfStmt ifStmt) { + + } + + @Override + public void visit(InstanceOf instanceOf) { + + } + + @Override + public void visit(LocalVar localVar) { + out.append(localVar.name); + } + + @Override + public void visit(LocalVarDecl localVarDecl) { + localVarDecl.getType().accept(this); + out.append(" " + localVarDecl.getName()); + } + + @Override + public void visit(MethodCall methodCall) { + methodCall.receiver.accept(this); + out.append("."+methodCall.name); + methodCall.getArgumentList().accept(this); + } + + @Override + public void visit(NewClass methodCall) { + out.append("new "); + out.append(methodCall.name); + methodCall.getArgumentList().accept(this); + } + + @Override + public void visit(NewArray newArray) { + + } + + @Override + public void visit(Receiver receiver) { + receiver.expr.accept(this); + } + + @Override + public void visit(Return aReturn) { + out.append("return "); + aReturn.retexpr.accept(this); + } + + @Override + public void visit(ReturnVoid aReturn) { + out.append("return"); + } + + @Override + public void visit(StaticClassName staticClassName) { + + } + + @Override + public void visit(Super aSuper) { + + } + + @Override + public void visit(This aThis) { + out.append("this"); + } + + @Override + public void visit(UnaryPlus unaryPlus) { + + } + + @Override + public void visit(WhileStmt whileStmt) { + + } + + @Override + public void visit(Null aNull) { + + } + + @Override + public void visit(Literal literal) { + + } +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/syntaxtree/visual/TypeOutputGenerator.java b/src/de/dhbwstuttgart/syntaxtree/visual/TypeOutputGenerator.java new file mode 100644 index 00000000..c0628ef9 --- /dev/null +++ b/src/de/dhbwstuttgart/syntaxtree/visual/TypeOutputGenerator.java @@ -0,0 +1,236 @@ +package de.dhbwstuttgart.syntaxtree.visual; + +import de.dhbwstuttgart.syntaxtree.*; +import de.dhbwstuttgart.syntaxtree.statement.*; +import de.dhbwstuttgart.syntaxtree.statement.literal.Literal; +import de.dhbwstuttgart.syntaxtree.statement.literal.Null; +import de.dhbwstuttgart.syntaxtree.type.*; + +import java.lang.reflect.Modifier; +import java.util.Iterator; + +public class TypeOutputGenerator extends OutputGenerator { + + TypeOutputGenerator(StringBuilder out){ + super(out); + } + + @Override + public void visit(SourceFile sourceFile) { + super.visit(sourceFile); + } + + @Override + public void visit(ArgumentList argumentList) { + super.visit(argumentList); + } + + @Override + public void visit(GenericTypeVar genericTypeVar) { + super.visit(genericTypeVar); + } + + @Override + public void visit(FormalParameter formalParameter) { + super.visit(formalParameter); + } + + @Override + public void visit(GenericDeclarationList genericTypeVars) { + super.visit(genericTypeVars); + } + + @Override + public void visit(Field field) { + super.visit(field); + } + + @Override + public void visit(Method method) { + super.visit(method); + } + + @Override + public void visit(ParameterList formalParameters) { + super.visit(formalParameters); + } + + @Override + public void visit(ClassOrInterface classOrInterface) { + super.visit(classOrInterface); + } + + @Override + public void visit(RefType refType) { + super.visit(refType); + } + + @Override + public void visit(SuperWildcardType superWildcardType) { + super.visit(superWildcardType); + } + + @Override + public void visit(TypePlaceholder typePlaceholder) { + super.visit(typePlaceholder); + } + + @Override + public void visit(ExtendsWildcardType extendsWildcardType) { + super.visit(extendsWildcardType); + } + + @Override + public void visit(GenericRefType genericRefType) { + super.visit(genericRefType); + } + + @Override + public void visit(LambdaExpression lambdaExpression) { + out.append("("); + super.visit(lambdaExpression); + out.append(")"); + this.out.append("::"); + lambdaExpression.getType().accept(this); + } + + @Override + public void visit(Assign assign) { + super.visit(assign); + } + + @Override + public void visit(Binary binary) { + super.visit(binary); + } + + @Override + public void visit(Block block) { + out.append("("); + super.visit(block); + out.append(")"); + this.out.append("::"); + block.getType().accept(this); + } + + @Override + public void visit(CastExpr castExpr) { + super.visit(castExpr); + } + + @Override + public void visit(EmptyStmt emptyStmt) { + super.visit(emptyStmt); + } + + @Override + public void visit(FieldVar fieldVar) { + out.append("("); + super.visit(fieldVar); + out.append(")"); + this.out.append("::"); + fieldVar.getType().accept(this); + } + + @Override + public void visit(ForStmt forStmt) { + super.visit(forStmt); + } + + @Override + public void visit(IfStmt ifStmt) { + super.visit(ifStmt); + } + + @Override + public void visit(InstanceOf instanceOf) { + super.visit(instanceOf); + } + + @Override + public void visit(LocalVar localVar) { + out.append("("); + super.visit(localVar); + out.append(")"); + this.out.append("::"); + localVar.getType().accept(this); + } + + @Override + public void visit(LocalVarDecl localVarDecl) { + super.visit(localVarDecl); + } + + @Override + public void visit(MethodCall methodCall) { + out.append("("); + super.visit(methodCall); + out.append(")"); + this.out.append("::"); + methodCall.getType().accept(this); + } + + @Override + public void visit(NewClass methodCall) { + super.visit(methodCall); + } + + @Override + public void visit(NewArray newArray) { + super.visit(newArray); + } + + @Override + public void visit(Receiver receiver) { + super.visit(receiver); + } + + @Override + public void visit(Return aReturn) { + super.visit(aReturn); + } + + @Override + public void visit(ReturnVoid aReturn) { + super.visit(aReturn); + } + + @Override + public void visit(StaticClassName staticClassName) { + super.visit(staticClassName); + } + + @Override + public void visit(Super aSuper) { + super.visit(aSuper); + } + + @Override + public void visit(This aThis) { + out.append("("); + super.visit(aThis); + out.append(")"); + this.out.append("::"); + aThis.getType().accept(this); + } + + @Override + public void visit(UnaryPlus unaryPlus) { + super.visit(unaryPlus); + } + + @Override + public void visit(WhileStmt whileStmt) { + super.visit(whileStmt); + } + + @Override + public void visit(Null aNull) { + super.visit(aNull); + } + + @Override + public void visit(Literal literal) { + super.visit(literal); + } +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java b/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java index 55b052ee..e30f0aa4 100644 --- a/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java +++ b/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java @@ -128,10 +128,11 @@ public class TypeInsertFactory { //Offset zum Einstzen bestimmen: Token offset; String insert = ""; - String end =" "; + String end; if(cl.getGenerics().iterator().hasNext()){ - offset = cl.getGenerics().iterator().next().getOffset(); - insert+=","; + //offset = cl.getGenerics().iterator().next().getOffset(); + offset = cl.getGenerics().getOffset(); + end=","; }else{ offset = cl.getGenerics().getOffset(); insert += "<"; @@ -154,6 +155,7 @@ public class TypeInsertFactory { //String zum Einsetzen (Generics mit bounds) generieren: Iterator it = genericsAndBounds.keySet().iterator(); + if(! it.hasNext())return new TypeInsertPoint(offset, ""); while(it.hasNext()){ TypePlaceholder tph = it.next(); insert += tph.getName(); diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java b/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java index 3a444c7d..0ecf638f 100644 --- a/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java +++ b/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java @@ -11,7 +11,7 @@ public class TypeInsertPoint { public TypeInsertPoint(Token point, String toInsert){ this.point = point; - this.insertString = toInsert + " "; + this.insertString = (toInsert.length()>1) ? toInsert + " " : toInsert; } public String insert(String intoSource, List additionalOffset){ diff --git a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java index 6d76a462..a799d8e2 100644 --- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java +++ b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java @@ -118,11 +118,6 @@ public class TYPE implements StatementVisitor{ throw new NotImplementedException(); } - @Override - public void visit(InstVar instVar) { - throw new NotImplementedException(); - } - @Override public void visit(LocalVar localVar) { // Es werden nur bei Feldvariablen Constraints generiert. Lokale Variablen sind eindeutig diff --git a/test/javFiles/Faculty.jav b/test/javFiles/Faculty.jav index 45988212..f69a48c7 100644 --- a/test/javFiles/Faculty.jav +++ b/test/javFiles/Faculty.jav @@ -1,9 +1,9 @@ class Faculty { - Integer mul(Integer x, Integer y) { + Integer mul(Integer x, Integer y) { return x; } - + m () { auto fact = (Integer x) -> { return mul(x, fact.apply(x)); diff --git a/test/typeinference/JavaTXCompilerTest.java b/test/typeinference/JavaTXCompilerTest.java index f1af81cd..8b3175cb 100644 --- a/test/typeinference/JavaTXCompilerTest.java +++ b/test/typeinference/JavaTXCompilerTest.java @@ -3,6 +3,10 @@ package typeinference; import de.dhbwstuttgart.core.JavaTXCompiler; import de.dhbwstuttgart.parser.ClassNotFoundException; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; +import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; +import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter; +import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter; +import de.dhbwstuttgart.syntaxtree.visual.OutputGenerator; import de.dhbwstuttgart.typedeployment.TypeInsert; import de.dhbwstuttgart.typedeployment.TypeInsertPoint; import de.dhbwstuttgart.typeinference.ResultSet; @@ -19,7 +23,7 @@ import java.util.List; import static org.junit.Assert.*; -public class JavaTXCompilerTest { +public class JavaTXCompilerTest extends JavaTXCompiler { private static final String rootDirectory = System.getProperty("user.dir")+"/test/javFiles/"; private static final List filesToTest = new ArrayList<>(); @@ -35,10 +39,10 @@ public class JavaTXCompilerTest { //filesToTest.add(new File(rootDirectory+"Generics.jav")); //filesToTest.add(new File(rootDirectory+"MethodsEasy.jav")); //filesToTest.add(new File(rootDirectory+"Matrix.jav")); - JavaTXCompiler compiler = new JavaTXCompiler(); for(File f : filesToTest){ - compiler.parse(f); - List result = compiler.getTypeInserts(f); + this.parse(f); + System.out.println(ASTTypePrinter.print(this.sourceFiles.get(sourceFiles.size()-1))); + List result = this.getTypeInserts(f); String content = readFile(f.getPath(), StandardCharsets.UTF_8); for(TypeInsert tip : result){ System.out.println(tip.insert(content)); @@ -53,4 +57,5 @@ public class JavaTXCompilerTest { byte[] encoded = Files.readAllBytes(Paths.get(path)); return new String(encoded, encoding); } -} \ No newline at end of file + +}