From 850fe3942689042fa056f90ce881522bc1c097b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= Date: Tue, 19 Mar 2019 16:31:04 +0100 Subject: [PATCH] modified: ../../../main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java Typen mit Argumenten korrgiert --- .../SyntaxTreeGenerator/TypeGenerator.java | 44 +++++++++++++++++-- .../resources/bytecode/javFiles/Matrix.jav | 4 +- .../resources/bytecode/javFiles/MatrixOP.jav | 4 +- 3 files changed, 45 insertions(+), 7 deletions(-) diff --git a/src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java b/src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java index ce85bf6d..d55e9349 100644 --- a/src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java +++ b/src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java @@ -3,16 +3,18 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator; import de.dhbwstuttgart.exceptions.NotImplementedException; import de.dhbwstuttgart.exceptions.TypeinferenceException; import de.dhbwstuttgart.parser.antlr.Java8Parser; +import de.dhbwstuttgart.parser.antlr.Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext; import de.dhbwstuttgart.parser.scope.GenericsRegistry; import de.dhbwstuttgart.parser.scope.JavaClassName; import de.dhbwstuttgart.parser.scope.JavaClassRegistry; import de.dhbwstuttgart.syntaxtree.GenericDeclarationList; import de.dhbwstuttgart.syntaxtree.GenericTypeVar; import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; +import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType; import de.dhbwstuttgart.syntaxtree.type.GenericRefType; import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; - +import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import org.antlr.v4.runtime.Token; @@ -24,12 +26,14 @@ import java.util.regex.Pattern; public class TypeGenerator { public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.UnannClassOrInterfaceTypeContext unannClassOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) { - Java8Parser.TypeArgumentsContext arguments; + Java8Parser.TypeArgumentsContext arguments=null; + /* PL 2019-03-19 auskommentiert ANFANG if(unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType() != null){ arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); }else{// if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){ arguments = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); } + PL 2019-03-19 auskommentiert ENDE */ /** * Problem sind hier die verschachtelten Typen mit verschachtelten Typargumenten * Beispiel: Typ.InnererTyp @@ -37,6 +41,28 @@ public class TypeGenerator { String name = unannClassOrInterfaceTypeContext.getText(); if(name.contains("<")){ name = name.split("<")[0]; //Der Typ ist alles vor den ersten Argumenten + /* Fuer Debug-Zwecke + unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType(); + unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().getText(); + //unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); + //UnannClassType_lfno_unannClassOrInterfaceTypeContext + unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(0); + unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(0).getText(); + unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(1); + unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(1).getText(); + unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().getText(); + //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType(); + //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType(0).getText(); + //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType(1).getText(); + //unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().getText(); + */ + int lastElement = new ArrayList<>(unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType()).size()-1; + if (lastElement >=0) {//qualifizierter Name z.B.: java.util.Vector + arguments = unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(lastElement).typeArguments(); + } + else { //unqualifizierter Name z.B.: Vector + arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); + } } return convertTypeName(name, arguments, unannClassOrInterfaceTypeContext.getStart(), reg, generics); } @@ -134,6 +160,18 @@ public class TypeGenerator { throw new NotImplementedException(); } } + + public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.WildcardContext wildcardContext, JavaClassRegistry reg, GenericsRegistry generics) { + if(wildcardContext.wildcardBounds() != null){ + if(wildcardContext.wildcardBounds().getText().substring(0, 7).equals("extends")){ + return new ExtendsWildcardType(convert(wildcardContext.wildcardBounds().referenceType(), reg, generics), wildcardContext.getStart()); + }else{ + return new SuperWildcardType(convert(wildcardContext.wildcardBounds().referenceType(), reg, generics), wildcardContext.getStart()); + } + }else{ + throw new NotImplementedException(); //Wildcard ohne Bound + } + } public static RefTypeOrTPHOrWildcardOrGeneric convertTypeName(String name, Token offset, JavaClassRegistry reg, GenericsRegistry generics){ return convertTypeName(name, null, offset, reg, generics); @@ -169,7 +207,7 @@ public class TypeGenerator { List ret = new ArrayList<>(); for(Java8Parser.TypeArgumentContext arg : typeArguments.typeArgumentList().typeArgument()){ if(arg.wildcard() != null){ - throw new NotImplementedException(); + ret.add(convert(arg.wildcard(), reg, generics)); }else{ ret.add(convert(arg.referenceType(), reg, generics)); } diff --git a/src/test/resources/bytecode/javFiles/Matrix.jav b/src/test/resources/bytecode/javFiles/Matrix.jav index 29505161..cfab616b 100644 --- a/src/test/resources/bytecode/javFiles/Matrix.jav +++ b/src/test/resources/bytecode/javFiles/Matrix.jav @@ -4,7 +4,7 @@ import java.lang.Float; //import java.lang.Byte; //import java.lang.Boolean; -public class Matrix extends Vector> { +public class Matrix extends Vector> { Matrix () { } @@ -19,7 +19,7 @@ public class Matrix extends Vector> { } } - mul(m) { + mul(java.util.Vector> m) { var ret = new Matrix(); var i = 0; while(i < size()) { diff --git a/src/test/resources/bytecode/javFiles/MatrixOP.jav b/src/test/resources/bytecode/javFiles/MatrixOP.jav index 638cff35..37172184 100644 --- a/src/test/resources/bytecode/javFiles/MatrixOP.jav +++ b/src/test/resources/bytecode/javFiles/MatrixOP.jav @@ -3,7 +3,7 @@ import java.lang.Integer; //import java.lang.Byte; import java.lang.Boolean; -public class MatrixOP extends Vector> { +public class MatrixOP extends Vector> { MatrixOP () { } @@ -18,7 +18,7 @@ public class MatrixOP extends Vector> { } } - mul = (m1, m2) -> { + Fun2$$>, java.util.Vector>, MatrixOP> mul = (m1, m2) -> { var ret = new MatrixOP(); var i = 0; while(i < m1.size()) {