Neue Klasse MethodCallHelper und Exceptions definiert, die fuer die

Uebersetzung von MethodCalls verwendet werden

src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java

@@ -33,12 +33,14 @@ import org.objectweb.asm.Type;
 import org.objectweb.asm.signature.SignatureVisitor;
 import org.objectweb.asm.signature.SignatureWriter;
 
+import de.dhbwstuttgart.bytecode.Exception.NotInCurrentPackageException;
 import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.bytecode.signature.Signature;
 import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
 import de.dhbwstuttgart.bytecode.utilities.KindOfLambda;
 import de.dhbwstuttgart.bytecode.utilities.Lambda;
+import de.dhbwstuttgart.bytecode.utilities.MethodCallHelper;
 import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
 import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
@@ -52,6 +54,7 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+import javassist.NotFoundException;
 
 public class BytecodeGenMethod implements StatementVisitor {
 
@@ -763,7 +766,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	public void visit(InstanceOf instanceOf) {
 
 	}
-
+	
 	@Override
 	public void visit(MethodCall methodCall) {
 		boolean parentBinary = isParentBinary;
@@ -772,6 +775,12 @@ public class BytecodeGenMethod implements StatementVisitor {
 		System.out.println("Methods of " + receiverName + " ");
 		java.lang.reflect.Method methodRefl = null;
 		String clazz = receiverName.replace("/", ".");
+		
+		String mDesc = "";
+		
+		MethodCallHelper helper = new MethodCallHelper(methodCall, sf, resultSet);
+		
+		boolean isCreated = false;
 //		if(!receiverName.equals(className)) {
 			ClassLoader cLoader = ClassLoader.getSystemClassLoader();
 			// This will be used if the class is not standard class (not in API)
@@ -801,71 +810,75 @@ public class BytecodeGenMethod implements StatementVisitor {
 					String superClass = "";
 					// TODO: Test SubMatrix.jav
 					while(true) {
-						for(ClassOrInterface cl : sf.getClasses()) {
-							if(receiverName.equals(cl.getClassName().toString())) {
-								superClass = cl.getSuperClass().getName().toString();
-								break;
-							}
-						}
-						System.out.println(superClass);
-						
-						if(superClass.equals(""))
-							break;
-						
 						try {
-							String superClazz = superClass.replace("/", ".");
+							superClass = helper.getSuperClass(receiverName);
-							if(superClass.contains("<")) {
-								superClazz = superClazz.substring(0, superClass.indexOf("<"));
-							}
-							java.lang.reflect.Method[] methods = cLoader.loadClass(superClazz).getMethods();
-							System.out.println("Methods of " + superClass + " ");
 							
-							for(java.lang.reflect.Method m : methods) {
+							try {
-								if(methodCall.name.equals(m.getName())) {
+								String superClazz = superClass.replace("/", ".");
-									methodRefl = m;
+								if(superClass.contains("<")) {
-									break;
+									superClazz = superClazz.substring(0, superClass.indexOf("<"));
 								}
+								java.lang.reflect.Method[] methods = cLoader.loadClass(superClazz).getMethods();
+								System.out.println("Methods of " + superClass + " ");
+								
+								for(java.lang.reflect.Method m : methods) {
+									if(methodCall.name.equals(m.getName())) {
+										methodRefl = m;
+										break;
+									}
+								}
+								
+								break;
+							} catch (Exception e3) {
+								receiverName = superClass;
+								continue;
 							}
-							
+						} catch (NotInCurrentPackageException e2) {
 							break;
-						} catch (Exception e3) {
-							receiverName = superClass;
-							continue;
 						}
+						
 					}
 //				}
 				
 			}
 			
 			if(methodRefl == null) {
-				try {
+				isCreated = !receiverName.equals(className) && helper.isInCurrPkg(clazz);
-					cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
+				if(isCreated) {
-					java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
+					try {
-					System.out.println("Methods of " + receiverName + " ");
+						mDesc = helper.getDesc(clazz);
-					for(int i = 0; i<methods.length; i++) {
+					} catch (NotInCurrentPackageException | NotFoundException e) {
-						System.out.println(methods[i]);
+						e.printStackTrace();
+					}
+				} else if(!helper.isInCurrPkg(clazz)){
+					try {
+						cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
+						java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
+						System.out.println("Methods of " + receiverName + " ");
+						for(int i = 0; i<methods.length; i++) {
+							System.out.println(methods[i]);
+						}
+						methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
+					}
+					catch (Exception e2) {
+						e2.printStackTrace();
 					}
-					methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
-				}
-				catch (Exception e2) {
-					System.out.println("");
-					//do nothing
 				}
+				
 			}
 //		}
 		
 		methodCall.receiver.accept(this);
 		
 		System.out.println("Methodcall type : " + resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()));
-		String mDesc = "";
 		List<Boolean> argListMethCall = new LinkedList<>();
 		String receiverRefl="";
-		if(methodRefl == null) {
+		if(methodRefl == null && receiverName.equals(className)) {
 			MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
 					receiverName, genericsAndBoundsMethod, genericsAndBounds);
 			mDesc = method.accept(new DescriptorToString(resultSet));
 			methodCall.arglist.accept(this);
-		} else {
+		} else if(methodRefl != null) {
 			System.out.println(methodCall.name + " -> Refl != null");
 			receiverRefl = methodRefl.getAnnotatedReceiverType().getType().toString();
 			for(Parameter p:methodRefl.getParameters()) {
@@ -880,6 +893,8 @@ public class BytecodeGenMethod implements StatementVisitor {
 				al.accept(argV);
 				statement = null;
 			}
+		} else {
+			methodCall.arglist.accept(this);
 		}
 		
 		System.out.println("Methodcall ("+ methodCall.name +") Desc : " + mDesc);
@@ -917,6 +932,19 @@ public class BytecodeGenMethod implements StatementVisitor {
 		
 	}
 	
+	private String getDescForMethInCurrPkg(String name) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	private boolean isInCurrPkg(String superClass) {
+		for(ClassOrInterface cl : sf.KlassenVektor) {
+			if(superClass.equals(cl.getClassName().toString()))
+				return true;
+		}
+		return false;
+	}
+
 	private String[] getTypes(List<Expression> arguments) {
 		String[] types = new String[arguments.size()];
 		for(int i = 0; i<arguments.size(); ++i) {
@@ -1252,10 +1280,16 @@ public class BytecodeGenMethod implements StatementVisitor {
 			visitBooleanLiteral((Boolean) value);
 			break;
 		case "java/lang/Byte":
-			visitByteLiteral(((Double) value).byteValue(), false);
+			if(value instanceof Double)
+				visitByteLiteral(((Double) value).byteValue(), false);
+			if(value instanceof Integer)
+				visitByteLiteral(((Integer) value).byteValue(), false);
 			break;
 		case "java/lang/Short":
-			visitShortLiteral(((Double) value).shortValue(), false);
+			if(value instanceof Double)
+				visitShortLiteral(((Double) value).shortValue(), false);
+			if(value instanceof Integer)
+				visitShortLiteral(((Integer) value).shortValue(), false);
 			break;
 		case "java/lang/Integer":
 			// zweite Argument isLong
@@ -1266,10 +1300,16 @@ public class BytecodeGenMethod implements StatementVisitor {
 				visitIntegerLiteral(((Integer) value).intValue(), false);
 			break;
 		case "java/lang/Long":
-			visitLongLiteral(((Integer) value).longValue(), true);
+			if(value instanceof Double)
+				visitLongLiteral(((Double) value).longValue(), true);
+			if(value instanceof Integer)
+				visitLongLiteral(((Integer) value).longValue(), true);
 			break;
 		case "java/lang/Float":
-			visitFloatLiteral(((Double) value).floatValue());
+			if(value instanceof Double)
+				visitFloatLiteral(((Double) value).floatValue());
+			if(value instanceof Integer)
+				visitFloatLiteral(((Integer) value).floatValue());
 			break;
 		case "java/lang/Double":
 			if(value instanceof Double)

src/main/java/de/dhbwstuttgart/bytecode/Exception/NotFoundException.java

@@ -0,0 +1,25 @@
+/**
+ * 
+ */
+package de.dhbwstuttgart.bytecode.Exception;
+
+/**
+ * @author fayez
+ *
+ */
+public class NotFoundException extends Exception {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	/**
+	 * @param message
+	 */
+	public NotFoundException(String message) {
+		super(message);
+	}	
+	
+
+}

src/main/java/de/dhbwstuttgart/bytecode/Exception/NotInCurrentPackageException.java

@@ -0,0 +1,26 @@
+/**
+ * 
+ */
+package de.dhbwstuttgart.bytecode.Exception;
+
+/**
+ * @author fayez
+ *
+ */
+public class NotInCurrentPackageException extends Exception {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	/**
+	 * @param message
+	 */
+	public NotInCurrentPackageException(String message) {
+		super(message);
+	}
+	
+	
+
+}

src/main/java/de/dhbwstuttgart/bytecode/utilities/MethodCallHelper.java

@@ -0,0 +1,207 @@
+/**
+ * 
+ */
+package de.dhbwstuttgart.bytecode.utilities;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.objectweb.asm.Type;
+
+import de.dhbwstuttgart.bytecode.Exception.NotInCurrentPackageException;
+import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
+import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
+import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
+import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.statement.MethodCall;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import javassist.NotFoundException;
+
+/**
+ * @author fayez
+ *
+ */
+public class MethodCallHelper {
+	private MethodCall methCall;
+	private SourceFile sourceFile;
+	private ResultSet resultSet;
+
+	/**
+	 * @param methCall
+	 * @param sourceFile
+	 * @param resultSet
+	 */
+	public MethodCallHelper(MethodCall methCall, SourceFile sourceFile, ResultSet resultSet) {
+		this.methCall = methCall;
+		this.sourceFile = sourceFile;
+		this.resultSet = resultSet;
+	}
+
+	public String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
+		return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor());
+	}
+
+	public boolean isInCurrPkg(String className) {
+		for (ClassOrInterface cl : sourceFile.KlassenVektor) {
+			if (className.equals(cl.getClassName().toString()))
+				return true;
+		}
+		return false;
+	}
+
+	public String getSuperClass(String className) throws NotInCurrentPackageException {
+		
+		for (ClassOrInterface cl : sourceFile.getClasses()) {
+			if (className.equals(cl.getClassName().toString())) {
+				return cl.getSuperClass().getName().toString();
+			}
+		}
+		throw new NotInCurrentPackageException("Class " + className + " is not in the current package.");
+	}
+
+	public ClassOrInterface getClassFromCurrPkg(String className) throws NotInCurrentPackageException {
+		for (ClassOrInterface cl : sourceFile.KlassenVektor) {
+			if (className.equals(cl.getClassName().toString()))
+				return cl;
+		}
+		throw new NotInCurrentPackageException("Class of " + className + " is not in the current package.");
+	}
+
+	public String getDesc(String className) throws NotInCurrentPackageException, NotFoundException {
+		String name = methCall.name;
+		ClassOrInterface clazz = getClassFromCurrPkg(className);
+
+		Map<String, String> genAndBoundsClass = getGenericsAndBounds(clazz.getGenerics());
+		modifyGenAndBounds(genAndBoundsClass);
+		for (Method m : clazz.getMethods()) {
+			if (name.equals(m.getName())) {
+				Map<String, String> genAndBoundsMethod = getGenericsAndBoundsMethod(m.getGenerics());
+				modifyGenAndBounds(genAndBoundsMethod);
+				boolean hasGen = hasGen(m, genAndBoundsClass);
+				NormalMethod nm = new NormalMethod(m, (HashMap<String, String>) genAndBoundsClass,
+						(HashMap<String, String>) genAndBoundsMethod, hasGen);
+				return nm.accept(new DescriptorToString(resultSet));
+			}
+		}
+
+		throw new NotFoundException("Method " + name + " is not found");
+	}
+
+	private boolean hasGen(Method m, Map<String, String> genericsAndBounds) {
+		String retType = resultSet.resolveType(m.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
+		/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
+		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.contains("TPH ") || retType.contains("<");
+
+		Map<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
+		Iterator<FormalParameter> itr = m.getParameterList().iterator();
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+			methodParamsAndTypes.put(fp.getName(), resultSet.resolveType(fp.getType()).resolvedType);
+		}
+		/*Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature, wenn nicht,
+		 * prüfe, ob einer der Parameter Typ-Variable als Typ hat*/
+		if(!hasGenInParameterList) {
+			for(String paramName : methodParamsAndTypes.keySet()) {
+				String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
+				String sigOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
+				if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.contains("TPH ")||sigOfParam.contains("<")) {
+					hasGenInParameterList = true;
+					break;
+				}
+			}
+		}
+		return m.getGenerics().iterator().hasNext() || hasGenInParameterList;
+	}
+
+	private Map<String, String> getGenericsAndBoundsMethod(Iterable<? extends GenericTypeVar> generics) {
+		Map<String, String> genAndBounds = new HashMap<>();
+		Iterator<? extends GenericTypeVar> itr = generics.iterator();
+		while (itr.hasNext()) {
+			GenericTypeVar gtv = itr.next();
+			getBoundsOfTypeVar(gtv, genAndBounds);
+		}
+		return genAndBounds;
+	}
+
+	private void modifyGenAndBounds(Map<String, String> genAndBoundsClass) {
+		List<String> visited = new ArrayList<>(genAndBoundsClass.size());
+		Map<String, String> toReplace = new HashMap<>();
+		for (String tv : genAndBoundsClass.keySet()) {
+
+			if (visited.contains(tv))
+				continue;
+
+			List<String> types = new LinkedList<>();
+			String bound = genAndBoundsClass.get(tv);
+			types.add(tv);
+			visited.add(tv);
+			boolean doReplace = false;
+			while (genAndBoundsClass.keySet().contains(bound)) {
+				doReplace = true;
+				types.add(bound);
+				visited.add(bound);
+				bound = genAndBoundsClass.get(bound);
+			}
+
+			if (doReplace) {
+				for (String tt : types) {
+					toReplace.put(tt, bound);
+				}
+			}
+		}
+
+		for (String key : toReplace.keySet()) {
+			genAndBoundsClass.replace(key, toReplace.get(key));
+		}
+
+	}
+
+	private Map<String, String> getGenericsAndBounds(GenericDeclarationList generics) {
+		Map<String, String> genAndBounds = new HashMap<>();
+		Iterator<GenericTypeVar> itr = generics.iterator();
+		while (itr.hasNext()) {
+			GenericTypeVar gtv = itr.next();
+			getBoundsOfTypeVar(gtv, genAndBounds);
+		}
+		return genAndBounds;
+	}
+
+	private void getBoundsOfTypeVar(GenericTypeVar g, Map<String, String> genAndBounds) {
+
+		Iterator<? extends RefTypeOrTPHOrWildcardOrGeneric> bItr = g.getBounds().iterator();
+		while (bItr.hasNext()) {
+			RefTypeOrTPHOrWildcardOrGeneric b = bItr.next();
+			String boundDesc = b.acceptTV(new TypeToDescriptor());
+			genAndBounds.put(g.getName(), boundDesc);
+		}
+	}
+
+	private String createDesc(Method m) {
+		String desc = "(";
+		for (FormalParameter fp : m.getParameterList()) {
+			String typeName = getResolvedType(fp.getType());
+			RefTypeOrTPHOrWildcardOrGeneric type = resultSet.resolveType(fp.getType()).resolvedType;
+			if (type instanceof TypePlaceholder) {
+				desc += "L" + Type.getInternalName(Object.class) + ";";
+			} else if (type instanceof GenericRefType) {
+				GenericRefType grt = (GenericRefType) type;
+
+			}
+		}
+		return null;
+	}
+
+}

src/test/resources/bytecode/javFiles/OL.jav

@@ -10,8 +10,6 @@ public class OL     {
 	
 }
 
-         
-
 public class OLMain   {
 
 	main(x) {