modified: src/de/dhbwstuttgart/core/JavaTXCompiler.java

modified:   src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
Zeilen 606 - 623 eingefuegt, um die parallel berechneten Ergebnisse richtig zu filtern
TODO
- Fuer Variance -1 muss das gleiche gemacht werden
- ab Zeile 550: nextSetasListRest muss nach jedem fork aufruf gefiltert werden.

src/de/dhbwstuttgart/bytecode/ArgumentVisitor.java

@@ -0,0 +1,255 @@
+package de.dhbwstuttgart.bytecode;
+
+import java.util.List;
+
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
+import de.dhbwstuttgart.syntaxtree.statement.Assign;
+import de.dhbwstuttgart.syntaxtree.statement.AssignToField;
+import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.statement.CastExpr;
+import de.dhbwstuttgart.syntaxtree.statement.DoStmt;
+import de.dhbwstuttgart.syntaxtree.statement.EmptyStmt;
+import de.dhbwstuttgart.syntaxtree.statement.ExpressionReceiver;
+import de.dhbwstuttgart.syntaxtree.statement.FieldVar;
+import de.dhbwstuttgart.syntaxtree.statement.ForStmt;
+import de.dhbwstuttgart.syntaxtree.statement.IfStmt;
+import de.dhbwstuttgart.syntaxtree.statement.InstanceOf;
+import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.syntaxtree.statement.Literal;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
+import de.dhbwstuttgart.syntaxtree.statement.MethodCall;
+import de.dhbwstuttgart.syntaxtree.statement.NewArray;
+import de.dhbwstuttgart.syntaxtree.statement.NewClass;
+import de.dhbwstuttgart.syntaxtree.statement.Return;
+import de.dhbwstuttgart.syntaxtree.statement.ReturnVoid;
+import de.dhbwstuttgart.syntaxtree.statement.StaticClassName;
+import de.dhbwstuttgart.syntaxtree.statement.Super;
+import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
+import de.dhbwstuttgart.syntaxtree.statement.This;
+import de.dhbwstuttgart.syntaxtree.statement.UnaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.WhileStmt;
+
+public class ArgumentVisitor implements StatementVisitor {
+	private List<Boolean> argListMethCall;
+	private BytecodeGenMethod bytecodeGenMethod;
+	
+	public ArgumentVisitor(List<Boolean> argListMethCall, BytecodeGenMethod bytecodeGenMethod) {
+		this.argListMethCall = argListMethCall;
+		this.bytecodeGenMethod = bytecodeGenMethod;
+	}
+
+	@Override
+	public void visit(ArgumentList argumentList) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(LambdaExpression lambdaExpression) {
+		lambdaExpression.accept(bytecodeGenMethod);
+		// Zieltype des Lambas ist Funktionale Interface
+		// kann nie primitiv sein => un-/boxing wird hier nicht gebraucht
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(Assign assign) {
+		assign.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(assign.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(BinaryExpr binary) {
+		binary.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(binary.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(Block block) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(CastExpr castExpr) {
+		castExpr.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(castExpr.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(EmptyStmt emptyStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(FieldVar fieldVar) {
+		fieldVar.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(fieldVar.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(ForStmt forStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(IfStmt ifStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(InstanceOf instanceOf) {
+		instanceOf.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(instanceOf.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(LocalVar localVar) {
+		localVar.accept(bytecodeGenMethod);
+		if(!bytecodeGenMethod.isBinaryExp) {
+			if(argListMethCall.get(0))
+				bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(localVar.getType()));
+		}
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(LocalVarDecl localVarDecl) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(MethodCall methodCall) {
+		methodCall.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(methodCall.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(NewClass methodCall) {
+		methodCall.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(methodCall.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(NewArray newArray) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(Return aReturn) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(ReturnVoid aReturn) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(StaticClassName staticClassName) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(Super aSuper) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(This aThis) {
+		aThis.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(aThis.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(WhileStmt whileStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(DoStmt whileStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(AssignToField assignLeftSide) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(AssignToLocal assignLeftSide) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(SuperCall superCall) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(ExpressionReceiver expressionReceiver) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(UnaryExpr unaryExpr) {
+		unaryExpr.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(unaryExpr.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(Literal literal) {
+		literal.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(literal.getType()));
+		argListMethCall.remove(0);
+	}
+
+}

src/de/dhbwstuttgart/bytecode/BytecodeGen.java

@@ -16,6 +16,7 @@ import org.objectweb.asm.Type;
 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.signature.TypeToString;
 import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
@@ -44,7 +45,7 @@ public class BytecodeGen implements ASTVisitor {
 	private boolean isInterface;
 	private List<ResultSet> listOfResultSets;
 	private ResultSet resultSet;
-	
+	private SourceFile sf;
 	private String path;
 	
 	private int indexOfFirstParam = 0;
@@ -67,9 +68,10 @@ public class BytecodeGen implements ASTVisitor {
 	
 	ArrayList<String> methodNameAndParamsT = new ArrayList<>();
 	
-	public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets, String path) {
+	public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets,SourceFile sf ,String path) {
 		this.classFiles = classFiles;
 		this.listOfResultSets = listOfResultSets;
+		this.sf = sf;
 		this.path = path;
 	}
 	
@@ -77,7 +79,7 @@ public class BytecodeGen implements ASTVisitor {
 	public void visit(SourceFile sourceFile) {
 		for(ClassOrInterface cl : sourceFile.getClasses()) {
 			System.out.println("in Class: " + cl.getClassName().toString());
-			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets,path);
+			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets, sf, path);
 			cl.accept(classGen);
 			classGen.writeClass(cl.getClassName().toString());
 		}
@@ -129,7 +131,8 @@ public class BytecodeGen implements ASTVisitor {
 				 * Signature looks like:
 				 * <E:Ljava/...>Superclass 
 				 */
-				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty()) {
+				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty() || 
+						classOrInterface.getSuperClass().acceptTV(new TypeToSignature()).contains("<")) {
 					Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs);
 					sig = signature.toString();
 					System.out.println("Signature: => " + sig);
@@ -178,15 +181,17 @@ public class BytecodeGen implements ASTVisitor {
 		boolean hasGen = false;
 		
 		for(String paramName : methodParamsAndTypes.keySet()) {
-			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
+			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
-			if(genericsAndBounds.containsKey(typeOfParam)) {
+			if(genericsAndBounds.containsKey(typeOfParam) ||typeOfParam.substring(0, 4).equals("TPH ")
+					|| typeOfParam.contains("<")) {
 				hasGen = true;
 				break;
 			}
 		}
 		String sig = null;
 		if(hasGen) {
-			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes);
+			ArrayList<GenericInsertPair> pairs = simplifyPairs(field.name,tphExtractor.allPairs);
+			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes,resultSet,pairs);
 			sig = signature.toString();
 		}
 		NormalConstructor constructor = new NormalConstructor(field,genericsAndBounds,hasGen);
@@ -194,7 +199,7 @@ public class BytecodeGen implements ASTVisitor {
 		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc, sig, null);
 		mv.visitCode();		
 		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,field, mv,paramsAndLocals,cw,
-				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, path);
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
 		if(!field.getParameterList().iterator().hasNext()) {
 			mv.visitInsn(Opcodes.RETURN);
 		}
@@ -228,13 +233,15 @@ public class BytecodeGen implements ASTVisitor {
 		System.out.println(acc);
 		
 		/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
-		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.subSequence(0, 4).equals("TPH ");
+		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.subSequence(0, 4).equals("TPH ") ||
+										resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()).contains("<");
 		/*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());
-				if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.substring(0, 4).equals("TPH ")) {
+				String sigOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
+				if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.substring(0, 4).equals("TPH ")||sigOfParam.contains("<")) {
 					hasGenInParameterList = true;
 					break;
 				}
@@ -248,11 +255,9 @@ public class BytecodeGen implements ASTVisitor {
 		/* method.getGenerics: <....> RT method(..) 
 		 * */
 		boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList;
-		
 		/* if method has generics or return type is TPH, create signature */
 		// zwite operand muss weggelassen werden
-		if(hasGen||method.getReturnType().acceptTV(new TypeToString()).equals("TPH")) {
+		if(hasGen||resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToString()).equals("TPH")) {
-			
 			ArrayList<GenericInsertPair> pairs = simplifyPairs(method.name,tphExtractor.allPairs);
 			System.out.println(method.name + " => Simplified Pairs: ");
 			pairs.forEach(p->System.out.println(p.TA1.getName() + " -> "+p.TA2.getName()));
@@ -268,7 +273,7 @@ public class BytecodeGen implements ASTVisitor {
 
 		mv.visitCode();		
 		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,method, mv,paramsAndLocals,cw,
-				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, path);
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
 		
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();

src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java

@@ -8,9 +8,14 @@ import java.lang.invoke.CallSite;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
+import java.lang.reflect.Parameter;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -36,9 +41,12 @@ import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
 import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
@@ -55,11 +63,14 @@ public class BytecodeGenMethod implements StatementVisitor {
 	private boolean isInterface;
 	private HashMap<String, String> genericsAndBoundsMethod;
 	private HashMap<String, String> genericsAndBounds;
-	private boolean isBinaryExp = false;
+	public boolean isBinaryExp = false;
 	private String superClass;
 	private String path;
+	private SourceFile sf;
 	private IStatement statement = null;
-
+	
+//	private int numMethodCalls = 0;
+	
 	// for tests **
 	private String fieldName;
 	private String fieldDesc;
@@ -73,7 +84,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 	public BytecodeGenMethod(String className, String superClass,ResultSet resultSet, Method m, MethodVisitor mv,
 			HashMap<String, Integer> paramsAndLocals, ClassWriter cw, HashMap<String, String> genericsAndBoundsMethod,
-			HashMap<String, String> genericsAndBounds, boolean isInterface, HashMap<String, byte[]> classFiles, String path) {
+			HashMap<String, String> genericsAndBounds, boolean isInterface, HashMap<String, byte[]> classFiles, SourceFile sf,String path) {
 
 		this.className = className;
 		this.superClass = superClass;
@@ -86,6 +97,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.genericsAndBounds = genericsAndBounds;
 		this.isInterface = isInterface;
 		this.classFiles = classFiles;
+		this.sf = sf;
 		this.path = path;
 		
 		if (!isInterface)
@@ -116,7 +128,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.isBinaryExp =isBinary;
 	}
 	
-	private String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
+	public String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
 		return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor());
 	}
 
@@ -124,6 +136,11 @@ public class BytecodeGenMethod implements StatementVisitor {
 	public void visit(Block block) {
 		for (Statement stmt : block.getStatements()) {
 			stmt.accept(this);
+			if(stmt instanceof MethodCall) {
+				String ret = getResolvedType(((MethodCall) stmt).getType());
+				if(!ret.equals("void"))
+					mv.visitInsn(Opcodes.POP);
+			}
 		}
 	}
 
@@ -140,7 +157,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	public void visit(LocalVar localVar) {
 		// wenn String + String zuerst wird ein StringBuilder initialisiert dann
 		// wird die lokale Var geladen. Sonst wird zuerst die lokale Var geladen.
-
+		System.out.println(localVar.name);
 		mv.visitVarInsn(Opcodes.ALOAD, paramsAndLocals.get(localVar.name));
 
 		if (isBinaryExp) {
@@ -196,7 +213,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 		String largerType = getLargerType(lexpType, rexpType);
 		String typeOfBinary = getResolvedType(binary.getType());
-
+		
 		if (typeOfBinary.equals(Type.getInternalName(String.class))) {
 			mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(StringBuilder.class));
 			mv.visitInsn(Opcodes.DUP);
@@ -564,7 +581,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		// ")"+lam.getReturn.getBounds
 		Signature sig = new Signature(lambdaExpression, numberOfParams);
 		String name = "Fun" + numberOfParams + "$$";
-		classWriter.visit(Opcodes.V1_8, Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT, name, sig.toString(),
+		classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT, name, sig.toString(),
 				Type.getInternalName(Object.class), null);
 		MethodVisitor mvApply = classWriter.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT, "apply", methDesc,
 				methSig.toString(), null);
@@ -591,7 +608,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 	@Override
 	public void visit(CastExpr castExpr) {
-		// TODO Auto-generated method stub
 
 	}
 
@@ -603,7 +619,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 	@Override
 	public void visit(FieldVar fieldVar) {
-
 		fieldName = fieldVar.fieldVarName;
 		fieldDesc = "L" + getResolvedType(fieldVar.getType()) + ";";
 
@@ -631,51 +646,157 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 	@Override
 	public void visit(InstanceOf instanceOf) {
-		// TODO Auto-generated method stub
 
 	}
 
 	@Override
 	public void visit(MethodCall methodCall) {
-		
+		System.out.println("In MethodCall = " + methodCall.name);
-		//ClassLoader.getSystemClassLoader().loadClass(className).getMethod(name, parameterTypes)
 		String receiverName = getResolvedType(methodCall.receiver.getType());
 		System.out.println("Methods of " + receiverName + " ");
-		ClassLoader cl = ClassLoader.getSystemClassLoader();
+		ClassLoader cLoader = ClassLoader.getSystemClassLoader();
+		java.lang.reflect.Method methodRefl = null;
+		String clazz = receiverName.replace("/", ".");
 		try {
-			java.lang.reflect.Method[] methods = cl.loadClass("java.util.Vector").getMethods();
+			if(receiverName.contains("<")) {
+				clazz = clazz.substring(0, receiverName.indexOf("<"));
+			}
+			java.lang.reflect.Method[] methods = cLoader.loadClass(clazz).getMethods();
 			System.out.println("Methods of " + receiverName + " ");
 			for(java.lang.reflect.Method m : methods) {
-				System.out.println(m.getName() + " " + m.toGenericString()+ " ==> ");
+				if(methodCall.name.equals(m.getName())) {
+					methodRefl = m;
+					break;
+				}
 			}
 		} catch (Exception e) {
-			// TODO Auto-generated catch block
+			String superClass = "";
-			e.printStackTrace();
+			// 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("/", ".");
+					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) {
+						if(methodCall.name.equals(m.getName())) {
+							methodRefl = m;
+							break;
+						}
+					}
+					
+					break;
+				} catch (Exception e2) {
+					receiverName = superClass;
+					continue;
+				}
+			}
+			
 		}
+		methodCall.receiver.accept(this);
 		
 		System.out.println("Methodcall type : " + resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()));
-		methodCall.receiver.accept(this);
+		String mDesc = "";
-		methodCall.arglist.accept(this);
+		List<Boolean> argListMethCall = new LinkedList<>();
-
+		if(methodRefl == null) {
-		MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
+			MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
-				genericsAndBoundsMethod, genericsAndBounds);
+					receiverName, genericsAndBoundsMethod, genericsAndBounds);
-		String mDesc = method.accept(new DescriptorToString(resultSet));
+			mDesc = method.accept(new DescriptorToString(resultSet));
+			methodCall.arglist.accept(this);
+		} else {
+			for(Parameter p:methodRefl.getParameters()) {
+				System.out.println(p.getName() + " und is Primitive = " + p.getType().isPrimitive());
+				argListMethCall.add(p.getType().isPrimitive());
+			}
+			mDesc = getMethodDesc(methodRefl);
+			for (Expression al : methodCall.arglist.getArguments()) {
+				statement = new ArgumentExpr(al);
+				ArgumentVisitor argV = new ArgumentVisitor(argListMethCall,this); 
+				al.accept(argV);
+				statement = null;
+			}
+		}
+		
 		System.out.println("Methodcall Desc : " + mDesc);
+		
+		
+//		methodCall.arglist.accept(this);
+		
 		// is methodCall.receiver functional Interface)?
 		if (varsFunInterface.contains(methodCall.receiver.getType())) {
-			mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, getResolvedType(methodCall.receiver.getType()), methodCall.name,
+			mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, clazz.replace(".", "/"), methodCall.name,
-					mDesc, false);
+					mDesc, true);
 		} else {
-			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, getResolvedType(methodCall.receiver.getType()), methodCall.name,
+			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, clazz.replace(".", "/"), methodCall.name,
 					mDesc, isInterface);
 		}
-		// test
+
-		// if(!methodCall.getType().toString().equals("V")) {
+		if(methodRefl != null && !methodRefl.getReturnType().isPrimitive()) {
-		// mv.visitInsn(Opcodes.POP);
+			if(methodRefl.getReturnType().equals(Object.class)) {
-		// }
+				String checkCast = getResolvedType(methodCall.getType());
-		if(isBinaryExp) {
+				int pos = checkCast.length();
-			doUnboxing(getResolvedType(methodCall.getType()));
+				if(checkCast.contains("<"))
+					pos = checkCast.indexOf("<");
+				mv.visitTypeInsn(Opcodes.CHECKCAST,checkCast.substring(0,pos));
+			}
+			if(isBinaryExp)
+				doUnboxing(getResolvedType(methodCall.getType()));
 		}
+		
+	}
+
+	private String getMethodDesc(java.lang.reflect.Method methodRefl) {
+		StringBuilder sb = new StringBuilder("(");
+	    
+		for(final Class c:(methodRefl.getParameterTypes()))
+	        sb= sb.append(getDescriptorForClass(c));
+	    
+	    sb.append(')');
+	    sb.append(getDescriptorForClass(methodRefl.getReturnType()));
+	    return sb.toString();
+	}
+
+	private String getDescriptorForClass(final Class c) {
+		if(c.isPrimitive())
+	    {
+	        if(c==byte.class)
+	            return "B";
+	        if(c==char.class)
+	            return "C";
+	        if(c==double.class)
+	            return "D";
+	        if(c==float.class)
+	            return "F";
+	        if(c==int.class)
+	            return "I";
+	        if(c==long.class)
+	            return "J";
+	        if(c==short.class)
+	            return "S";
+	        if(c==boolean.class)
+	            return "Z";
+	        if(c==void.class)
+	            return "V";
+	        
+	    }
+	    if(c.isArray()) 
+	    		return c.getName().replace('.', '/');
+	    
+	    return ('L'+c.getName()+';').replace('.', '/');
 	}
 
 	@Override
@@ -707,6 +828,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 	@Override
 	public void visit(UnaryExpr unaryExpr) {
+		
 		unaryExpr.expr.accept(this);
 		Operation op = unaryExpr.operation;
 
@@ -854,7 +976,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	}
 
 	// Unboxing: RefType -> prim
-	private void doUnboxing(String type) {
+	public void doUnboxing(String type) {
 		switch (type) {
 		case "java/lang/String":
 			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(StringBuilder.class), "append",
@@ -1079,14 +1201,5 @@ public class BytecodeGenMethod implements StatementVisitor {
 		
 		mv.visitVarInsn(Opcodes.ASTORE, paramsAndLocals.get(var));
 	}
-	
-	private class TPHEx extends AbstractASTWalker{
-		// Liste enthält alle tph der Methode
-		ArrayList<TypePlaceholder> allTPHS = new ArrayList<>();
-		@Override
-		public void visit(TypePlaceholder tph) {
-			allTPHS.add(tph);
-		}
-	}
 
 }

src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java

@@ -172,7 +172,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
 			String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 			
-			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
@@ -189,7 +189,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		System.out.println("DescriptorToString retType = " + retType);
 		if(retType.equals("void")) {
 			desc += ")V";
-		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(retType)) {

src/de/dhbwstuttgart/bytecode/signature/Signature.java

@@ -44,10 +44,13 @@ public class Signature {
 		createSignatureForClassOrInterface();
 	}
 
-	public Signature(Constructor constructor, HashMap<String, String> genericsAndBounds, HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes) {
+	public Signature(Constructor constructor, HashMap<String, String> genericsAndBounds, 
+			HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes,ResultSet resultSet,ArrayList<GenericInsertPair> methodPairs) {
 		this.constructor = constructor;
 		this.genericsAndBounds = genericsAndBounds;
 		this.methodParamsAndTypes = methodParamsAndTypes;
+		this.resultSet = resultSet;
+		this.methodPairs = methodPairs;
 		sw = new SignatureWriter();
 		createSignatureForConsOrMethod(this.constructor,true);
 	}
@@ -107,40 +110,49 @@ public class Signature {
 		
 		// Wenn die RückgabeType eine TPH ist, wird als generic behandelt
 		// z.B: Type = TPH K => wird eine Formal Type Parameter K$ erzeugt und Bound = Object
-		String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
+		if(!isConstructor) {
-		if(ret.substring(0,4).equals("TPH ")) {
+			String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
-			String g = ret.substring(4,ret.length())+"$";
+			System.out.println("RET:::: " + ret);
-			if(genericsAndBounds.containsKey(g)) {
+			if(!ret.equals("V")) {
-				genericsAndBoundsMethod.put(g, genericsAndBounds.get(g));
+				// TODO TypeToSignature nochmal kontrollieren und schauen ob man dort wirklich 
-			}else {
+				// T... braucht und L ...
-				sw.visitFormalTypeParameter(g);
+				if(ret.contains("$") && !ret.contains("$$")) {
-				sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+//					String g = ret.substring(4,ret.length())+"$";
-				genericsAndBoundsMethod.put(g, Type.getInternalName(Object.class));
+					if(genericsAndBounds.containsKey(ret)) {
-				sw.visitClassBound().visitEnd();
+						genericsAndBoundsMethod.put(ret.substring(1), genericsAndBounds.get(ret.substring(1)));
+					}else {
+						sw.visitFormalTypeParameter(ret.substring(1));
+						sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+						genericsAndBoundsMethod.put(ret.substring(1), Type.getInternalName(Object.class));
+						sw.visitClassBound().visitEnd();
+					}
+				}
+				
+				if(ret.contains("<")) {
+					RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType;
+					if(hasTPHs(ref)) {
+						createSignatureForParameterizedType(ref);
+					}
+					
+				}
 			}
 		}
 		
-		if(ret.contains("<")) {
-			RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType;
-			if(hasTPHs(ref)) {
-				createSignatureForParameterizedType(ref);
-			}
-			
-		}
-		
 		// Parameters
 		for(String paramName : methodParamsAndTypes.keySet()) {
 			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
 			String pT = t.acceptTV(new TypeToSignature()); 
 			// S.o
-			if(pT.substring(0,4).equals("TPH ")) {
+//			if(pT.substring(0,4).equals("TPH ")) {
-				String gP = pT.substring(4,pT.length())+"$";
+			if(t instanceof TypePlaceholder) {
-				if(!genericsAndBounds.containsKey(gP) && !genericsAndBoundsMethod.containsKey(gP)) {
+//				String gP = pT.substring(4,pT.length())+"$";
-					sw.visitFormalTypeParameter(gP);
+				String gP = t.acceptTV(new TypeToSignature());
+				if(!genericsAndBounds.containsKey(gP.substring(1)) && !genericsAndBoundsMethod.containsKey(gP.substring(1))) {
+					sw.visitFormalTypeParameter(gP.substring(1));
 					String bound = Type.getInternalName(Object.class);
 					boolean isTypeVar = false;
 					for(GenericInsertPair pair : methodPairs) {
-						if(pT.substring(4).equals(pair.TA1.getName())) {
+						if(pT.substring(1,pT.length()-1).equals(pair.TA1.getName())) {
 							bound = pair.TA2.getName()+"$";
 							isTypeVar = true;
 							break;
@@ -154,7 +166,7 @@ public class Signature {
 						sw.visitClassBound().visitEnd();
 					}
 					
-					genericsAndBoundsMethod.put(gP, bound);
+					genericsAndBoundsMethod.put(gP.substring(1), bound);
 				}
 			}
 			
@@ -199,7 +211,8 @@ public class Signature {
 			// parameter type deswegen ist true
 			doVisitParamsOrReturn(t,true);
 		}
-		if(isConstructor) {
+		if(isConstructor || 
+				resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()).equals("V")) {
 			sw.visitReturnType().visitBaseType('V');
 		}else {
 			RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
@@ -338,6 +351,10 @@ public class Signature {
 	
 	private boolean hasTPHs(RefType ref) {
 		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			System.out.println(p.acceptTV(new TypeToString()));
+			if(p.acceptTV(new TypeToString()).contains("WC")){
+				continue;
+			}
 			if(resultSet.resolveType(p).resolvedType instanceof TypePlaceholder)
 				return true;
 		}
@@ -361,24 +378,34 @@ public class Signature {
 		}
 		switch (type) {
 		case "RT":
-			sv.visitClassType(t.acceptTV(new TypeToSignature()));
+			String sig = t.acceptTV(new TypeToSignature());
+			sv.visitClassType(sig.substring(1, sig.length()));
 			break;
 		case "GRT":
 			GenericRefType g = (GenericRefType) t;
-			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()));
+			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()).substring(1));
 			break;
 		case "TPH":
 			RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
 			// der Fall wenn die Type eine Interface ist, muss betrachtet werden
 			// Deswegen muss in ResutSet noch enthalten werden, ob die Type eine
 			// Interface oder eine Klasse ist.
-			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
+			
+			// das braucht man nicht es reicht: sv.visitTypeVariable(r.acceptTV(new TypeToSignature())
+			// 
+//			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
+			String sig2 = r.acceptTV(new TypeToSignature());
+			if(!(r instanceof TypePlaceholder)) {
+				
 //				sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
-				sv.visitClassType(r.acceptTV(new TypeToSignature()));
+//				sv.visitClassType(r.acceptTV(new TypeToSignature()));
+				sv.visitClassType(sig2.substring(1, sig2.length()));
 			} else {
 				System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
-				sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
+//				sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
+				sv.visitTypeVariable(sig2.substring(1, sig2.length()));
 			}
+			
 			break;
 		default:
 			if(!isParameterType)
@@ -426,7 +453,8 @@ public class Signature {
 				}
 			}
 		}
-		sw.visitSuperclass().visitClassType(classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()));;
+		String sClass = classOrInterface.getSuperClass().acceptTV(new TypeToSignature());
+		sw.visitSuperclass().visitClassType(sClass.substring(1, sClass.length()-1));
 		sw.visitEnd();
 	}
 	/**

src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java

@@ -15,6 +15,8 @@ public class TypeToSignature implements TypeVisitor<String> {
 
 	@Override
 	public String visit(RefType refType) {
+		if(refType.getName().toString().equals("void"))
+			return "V";
 //		return refType.toString().replace(".", "/");
 		String params = "";
         if(refType.getParaList().size()>0){
@@ -22,34 +24,41 @@ public class TypeToSignature implements TypeVisitor<String> {
             Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = refType.getParaList().iterator();
             while(it.hasNext()){
                 RefTypeOrTPHOrWildcardOrGeneric param = it.next();
-                if(param instanceof TypePlaceholder) {
+//                if(param instanceof TypePlaceholder) {
-                		params += "T" + ((TypePlaceholder) param).getName() + "$";
+//                	params += "T" + ((TypePlaceholder) param).getName() + "$";
-                } else {
+//                } else if(param instanceof ExtendsWildcardType) {
-                		params += "L"+param.toString().replace(".", "/");
+//                	params += "+" + ((ExtendsWildcardType) param).getInnerType().acceptTV(new TypeToSignature());
-                }
+//                } else if(param instanceof SuperWildcardType) {
-                
+//                	params += "-" + ((SuperWildcardType) param).getInnerType().acceptTV(new TypeToSignature());
-                if(it.hasNext())params += ";";
+//                } else {
+//                		params += "L"+param.toString().replace(".", "/");
+//                }
+                params += param.acceptTV(new TypeToSignature());
+//                if(it.hasNext())params += ";";
             }
-            params += ";>";
+            params += ">";
         }
 //        		String t = refType.getName().toString().replace(".", "/");
 //        		return t.equals("Fun1")?t+"$$"+params+";":t+params+";";
-        return refType.getName().toString().replace(".", "/") + params+";";
+        return "L"+refType.getName().toString().replace(".", "/") + params+";";
 	}
 
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+//		throw new NotImplementedException();
+		return "-" + superWildcardType.getInnerType().acceptTV(new TypeToSignature());
 	}
 
 	@Override
 	public String visit(TypePlaceholder typePlaceholder) {
-		return typePlaceholder.toString().replace(".", "/");
+//		return typePlaceholder.toString().replace(".", "/");
+		return "T" + typePlaceholder.getName() + "$";
 	}
 
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
-		throw new NotImplementedException();
+//		throw new NotImplementedException();
+		return "+" + extendsWildcardType.getInnerType().acceptTV(new TypeToSignature());
 	}
 
 	@Override

src/de/dhbwstuttgart/bytecode/signature/TypeToString.java

@@ -17,7 +17,7 @@ public class TypeToString implements TypeVisitor<String>{
 
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+		return "SWC";
 	}
 
 	@Override
@@ -27,7 +27,7 @@ public class TypeToString implements TypeVisitor<String>{
 
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
-		throw new NotImplementedException();
+		return "EWC";
 	}
 
 	@Override

src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java

@@ -9,13 +9,16 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 public class MethodFromMethodCall {
 	private ArgumentList argList;
 	private RefTypeOrTPHOrWildcardOrGeneric returnType;
+	private String receiverName;
 	private HashMap<String, String> genericsAndBoundsMethod;
 	private HashMap<String,String> genericsAndBounds;
 	
-	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType,
+	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType, 
-			HashMap<String, String> genericsAndBoundsMethod,HashMap<String,String> genericsAndBounds) {
+			String receiverName, HashMap<String, String> genericsAndBoundsMethod,
+			HashMap<String,String> genericsAndBounds) {
 		this.argList = argList;
 		this.returnType = returnType;
+		this.receiverName = receiverName;
 		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
 		this.genericsAndBounds = genericsAndBounds;
 	}
@@ -28,6 +31,10 @@ public class MethodFromMethodCall {
 		return returnType;
 	}
 	
+	public String getReceiverName() {
+		return receiverName;
+	}
+	
 	public HashMap<String, String> getGenericsAndBoundsMethod(){
 		return genericsAndBoundsMethod;
 	}

src/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -24,6 +24,7 @@ import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
 import de.dhbwstuttgart.typeinference.unify.RuleSet;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
 import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
@@ -38,7 +39,7 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class JavaTXCompiler {
-
+	final boolean parallel = true;
     final CompilationEnvironment environment;
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
     Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"/test/logFiles/log" geschrieben werden soll?
@@ -117,6 +118,7 @@ public class JavaTXCompiler {
 				logFile.write(ASTTypePrinter.print(sf));
 			}
 			logFile.flush();
+			Set<TypeUnifyTask> forks = new HashSet<>();
 			Set<List<Constraint<UnifyPair>>> cardProd = unifyCons.cartesianProduct(); 
 			for (List<Constraint<UnifyPair>> xCons : cardProd ){
 				Set<UnifyPair> xConsSet = new HashSet<>();
@@ -175,15 +177,39 @@ public class JavaTXCompiler {
 					return y; } )
 				.collect(Collectors.toCollection(HashSet::new));
 					varianceInheritance(xConsSet);
-    				Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
+					if (parallel) {
-    				//Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+						//Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
-    				System.out.println("RESULT: " + result);
+						Set<UnifyPair> eq = new HashSet<>(xConsSet);
-    				logFile.write("RES: " + result.toString()+"\n");
+						TypeUnifyTask fork = new TypeUnifyTask(eq, finiteClosure, true, logFile, log);
-    				logFile.flush();
+						forks.add(fork);
-    				results.addAll(result);
+						fork.fork();
-            	}
+					}
-        	}
+					else {
-    		catch (IOException e) { }
+						Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
+						System.out.println("RESULT: " + result);
+		    			logFile.write("RES: " + result.toString()+"\n");
+		    			logFile.flush();
+		    			results.addAll(result);
+					}
+			}
+			for (TypeUnifyTask fork : forks) {
+				try {
+					Set<Set<UnifyPair>> result = fork.join();
+					System.out.println("RESULT: " + result);
+					logFile.write("RES: " + result.toString()+"\n");
+					logFile.flush();
+					results.addAll(result);
+				}
+				catch (ConcurrentModificationException v) {
+					v.printStackTrace();
+					while (v.getCause() instanceof ConcurrentModificationException) {
+						v = (ConcurrentModificationException)v.getCause();
+					}
+					System.out.println(v);
+				}
+			}
+        }
+    	catch (IOException e) { }
 			
 		return results.stream().map((unifyPairs ->
                new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
@@ -246,7 +272,7 @@ public class JavaTXCompiler {
     			HashMap<String,byte[]> classFiles = new HashMap<>();
     			SourceFile sf = sourceFiles.get(f);
     			List<ResultSet> typeinferenceResult = this.typeInference();
-    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult,path);
+    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult,sf,path);
 //    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult.get(0));
         		bytecodeGen.visit(sf);
         		this.writeClassFile(bytecodeGen.getClassFiles(), path);

src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java

@@ -198,7 +198,9 @@ public class UnifyTypeFactory {
             }else if(tr instanceof WildcardType){
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (WildcardType) tr);
             }else throw new NotImplementedException();
-        }else throw new NotImplementedException();
+        }else { 
+        	throw new NotImplementedException();
+        }
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {

src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java

@@ -202,7 +202,7 @@ public class TYPEStmt implements StatementVisitor{
                 unaryExpr.operation == UnaryExpr.Operation.PREINCREMENT){
             //@see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.14.2
             //Expression muss zu Numeric Convertierbar sein. also von Numeric erben
-            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), number, PairOperator.SMALLERDOT));
+            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), number, PairOperator.SMALLERNEQDOT));
             //The type of the postfix increment expression is the type of the variable
             constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), unaryExpr.getType(), PairOperator.EQUALSDOT));
         }else{
@@ -223,50 +223,75 @@ public class TYPEStmt implements StatementVisitor{
             //Zuerst der Fall für Numerische AusdrücPairOpnumericeratorke, das sind Mul, Mod und Div immer:
             //see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
             //Expression muss zu Numeric Convertierbar sein. also von Numeric erben
-            Constraint<Pair> numeric = new Constraint<>();
+            Constraint<Pair> numeric;
-            numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            //PL eingefuegt 2018-07-17
-            numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(bytee.getName())) {
-            numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+            	numeric = new Constraint<>();
-            numericAdditionOrStringConcatenation.add(numeric);
+            	numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
-            numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
-            numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
-            numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
+                numericAdditionOrStringConcatenation.add(numeric);
-            numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+            }
-            numericAdditionOrStringConcatenation.add(numeric);
+            //PL eingefuegt 2018-07-17
-            numeric = new Constraint<>();
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(shortt.getName())) {
-            numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
+            	numeric = new Constraint<>();
-            numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
-            numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
-            numericAdditionOrStringConcatenation.add(numeric);
+            	numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
-            numeric = new Constraint<>();
+            	numericAdditionOrStringConcatenation.add(numeric);
-            numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
+            }
-            numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
+            //PL eingefuegt 2018-07-17
-            numeric.add(new Pair(binary.getType(), longg, PairOperator.SMALLERDOT));
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(integer.getName())) {
-            numericAdditionOrStringConcatenation.add(numeric);
+            	numeric = new Constraint<>();
-            numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
-            numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
-            numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
-            numeric.add(new Pair(binary.getType(), floatt, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
-            numericAdditionOrStringConcatenation.add(numeric);
+            }
-            numeric = new Constraint<>();
+            //PL eingefuegt 2018-07-17
-            numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(longg.getName())) {
-            numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            	numeric = new Constraint<>();
-            numeric.add(new Pair(binary.getType(), doublee, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
-            numericAdditionOrStringConcatenation.add(numeric);
+            	numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), longg, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
+            }
+            //PL eingefuegt 2018-07-17
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(floatt.getName())) {
+            	numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), floatt, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
+            }
+            //PL eingefuegt 2018-07-17
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(doublee.getName())) {
+            	numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), doublee, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
+            }
+            /* PL auskommentiert Anfang 2018-07-17
             /*
             In Java passiert bei den binären Operatoren eine sogenannte Type Promotion:
             https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.6.2
             Das bedeutet, dass Java die Typen je nach belieben castet, so lange sie nur von Number erben
-             */
+             
+            numeric = new Constraint<>();
             numeric.add(new Pair(binary.getType(), number, PairOperator.SMALLERDOT));
             numericAdditionOrStringConcatenation.add(numeric);
+            * PL auskommentiert Ende 2018-07-17 */
+            
             if(binary.operation.equals(BinaryExpr.Operator.ADD)) {
                 //Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
-                Constraint<Pair> stringConcat = new Constraint<>();
+            	if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(string.getName())) {
-                stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT));
+            		Constraint<Pair> stringConcat = new Constraint<>();
-                stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT));
+            		stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT));
-                stringConcat.add(new Pair(binary.getType(), string, PairOperator.EQUALSDOT));
+            		stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT));
-                numericAdditionOrStringConcatenation.add(stringConcat);
+            		stringConcat.add(new Pair(binary.getType(), string, PairOperator.EQUALSDOT));
+            		numericAdditionOrStringConcatenation.add(stringConcat);
+            	}
             }
             constraintsSet.addOderConstraint(numericAdditionOrStringConcatenation);
         }else if(binary.operation.equals(BinaryExpr.Operator.LESSEQUAL) ||

src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.typeinference.unify;
 
 import java.io.FileWriter;
+import java.util.ConcurrentModificationException;
 import java.util.Set;
 import java.util.concurrent.ForkJoinPool;
 
@@ -11,7 +12,12 @@ public class TypeUnify {
 	public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true, logFile, log);
 		ForkJoinPool pool = new ForkJoinPool();
+		try {
 		pool.invoke(unifyTask);
+		}
+		catch (ConcurrentModificationException v) {
+			v.printStackTrace();
+		}
 		Set<Set<UnifyPair>> res =  unifyTask.join();
 		return res;
 	}

src/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.io.FileWriter;
+import java.util.HashSet;
+import java.util.Set;
+
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+public class TypeUnify2Task extends TypeUnifyTask {
+	
+	Set<Set<UnifyPair>> setToFlatten;
+
+	public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel, FileWriter logFile, Boolean log) {
+		super(eq, fc, parallel, logFile, log);
+		this.setToFlatten = setToFlatten;
+	}
+	
+	@Override
+	protected Set<Set<UnifyPair>> compute() {
+		if (one) {
+			System.out.println("two");
+		}
+		one = true;
+		Set<Set<UnifyPair>> res = unify2(setToFlatten, eq, fc, parallel);
+		/*if (isUndefinedPairSetSet(res)) { 
+			return new HashSet<>(); }
+		else
+		*/ 
+			return res;
+	}
+}

src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java

@@ -30,6 +30,7 @@ import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
 import de.dhbwstuttgart.typeinference.unify.model.Unifier;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
 import de.dhbwstuttgart.typeinference.unify.model.OrderingUnifyPair;
 
 import java.io.File;
@@ -49,9 +50,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	private static int i = 0;
 	private boolean printtag = false;
 	Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"/test/logFiles/log" geschrieben werden soll?
+	private static int noOfThread = 0;
+	private int thNo;
 	
 	public static final String rootDirectory = System.getProperty("user.dir")+"/test/logFiles/";
 	FileWriter logFile;
+	
+	protected boolean one = false;
 
 	/**
 	 * The implementation of setOps that will be used during the unification
@@ -96,6 +101,10 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		this.logFile = logFile;
 		this.log = log;
 		rules = new RuleSet(logFile);
+		noOfThread++;
+		thNo = noOfThread;
+		//System.out.println(noOfThread);
+		//System.out.println(eq);
 	}
 	
 	
@@ -133,6 +142,10 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 */
 	@Override
 	protected Set<Set<UnifyPair>> compute() {
+		if (one) {
+			System.out.println("two");
+		}
+		one = true;
 		Set<Set<UnifyPair>> res = unify(eq, fc, parallel);
 		if (isUndefinedPairSetSet(res)) { return new HashSet<>(); }
 		else return res;
@@ -144,7 +157,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	 * @param fc The finite closure
 	 * @return The set of all principal type unifiers
 	 */
-	protected Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel)  {
+	protected Set<Set<UnifyPair>> unify(final Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel)  {
 		//Set<UnifyPair> aas = eq.stream().filter(x -> x.getLhsType().getName().equals("AA") //&& x.getPairOp().equals(PairOperator.SMALLERDOT)
 		//		).collect(Collectors.toCollection(HashSet::new));
 		//writeLog(nOfUnify.toString() + " AA: " + aas.toString());
@@ -311,10 +324,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			 */
 			//System.out.println("vor Subst: " + eqPrime);
 			Optional<Set<UnifyPair>> eqPrimePrime = rules.subst(eqPrime);
+			Set<Set<UnifyPair>> unifyres1 = null;
+			Set<Set<UnifyPair>> unifyres2 = null;
 			
 			/*
 			 * Step 6 a) Restart (fork) for pairs where subst was applied
 			 */
+			/*
 			if(parallel) {
 				if (eqPrime.equals(eq) && !eqPrimePrime.isPresent())        //PL 2017-09-29 //(!eqPrimePrime.isPresent()) auskommentiert und durch 
 				                              								//PL 2017-09-29 dies ersetzt //(!eqPrimePrime.isPresent()) 
@@ -334,7 +350,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					fork.fork();
 				}
 			}
-			else { // sequentiell (Step 6b is included)
+			else */ 
+			{ // sequentiell (Step 6b is included)
 				if (printtag) System.out.println("nextStep: " + eqPrimePrime);
 				if (eqPrime.equals(eq) && !eqPrimePrime.isPresent()) {        //PL 2017-09-29 //(!eqPrimePrime.isPresent()) auskommentiert und durch 
 																			  //PL 2017-09-29 dies ersetzt //(!eqPrimePrime.isPresent()) 
@@ -350,12 +367,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					eqPrimePrimeSet.add(eqPrime);
 				}
 				else if(eqPrimePrime.isPresent()) {
-					Set<Set<UnifyPair>> unifyres = unify(eqPrimePrime.get(), fc, false);
+					Set<Set<UnifyPair>> unifyres = unifyres1 = unify(eqPrimePrime.get(), fc, parallel);
 					
 					eqPrimePrimeSet.addAll(unifyres);
 				}
 				else {
-					Set<Set<UnifyPair>> unifyres = unify(eqPrime, fc, false);
+					Set<Set<UnifyPair>> unifyres = unifyres2 = unify(eqPrime, fc, parallel);
 					
 					
 					eqPrimePrimeSet.addAll(unifyres);
@@ -368,17 +385,24 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		/*
 		 * 	Step 6 b) Build the union over everything.
 		 */
-		
+		/*
 		if(parallel)
 			for(TypeUnifyTask fork : forks) 
 				eqPrimePrimeSet.addAll(fork.join());
+		*/
 		
 		 /*
 		  * Step 7: Filter empty sets;
 		  */
 		eqPrimePrimeSet = eqPrimePrimeSet.stream().filter(x -> isSolvedForm(x) || this.isUndefinedPairSet(x)).collect(Collectors.toCollection(HashSet::new));
-		if (!eqPrimePrimeSet.isEmpty() && !isUndefinedPairSetSet(eqPrimePrimeSet))
+		if (!eqPrimePrimeSet.isEmpty() && !isUndefinedPairSetSet(eqPrimePrimeSet)) {
 			writeLog("Result1 " + eqPrimePrimeSet.toString());
+			Iterator<UnifyPair> upit = eqPrimePrimeSet.iterator().next().iterator();
+			if (upit.next().getLhsType() instanceof WildcardType 
+					|| upit.next().getLhsType() instanceof WildcardType) {
+				System.out.println("");
+			}
+		}
 		return eqPrimePrimeSet;
 	}
 	
@@ -451,9 +475,19 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		writeLog("nextSetasList: " + nextSetasList.toString());
 		while (nextSetasList.size() > 0) {  //(nextSetasList.size() != 0) {
 			Set<UnifyPair> a = null;
+			List<Set<UnifyPair>> nextSetasListRest= new ArrayList<>();
 			if (variance == 1) {
 				a = oup.max(nextSetasList.iterator());
 				nextSetasList.remove(a);
+				nextSetasListRest = new ArrayList<>(nextSetasList);
+				Iterator<Set<UnifyPair>> nextSetasListItRest = new ArrayList<Set<UnifyPair>>(nextSetasListRest).iterator();
+				while (nextSetasListItRest.hasNext()) {
+					Set<UnifyPair> a_next = nextSetasListItRest.next();
+					if (//a.equals(a_next) || 
+						(oup.compare(a, a_next) == 1)) {
+						nextSetasListRest.remove(a_next);
+					}
+				}
 			}
 			else if (variance == -1) {
 				a = oup.min(nextSetasList.iterator());
@@ -491,16 +525,62 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			elems.add(a);
 			//if (remainingSets.isEmpty()) {//muss immer gegeben sein, weil nur 1 Element der topLevelSets mehr als ein Elemet enthaelt
 				//writeLog("Vor unify2 Aufruf: " + eq.toString());
-				Set<Set<UnifyPair>> res = unify2(elems, eq, fc, parallel);
+			Set<Set<UnifyPair>> res = new HashSet<>();
+			Set<Set<Set<UnifyPair>>> add_res = new HashSet<>();
+			if(parallel && (variance == 1)) {
+				/*
+				elems.add(a);
+				TypeUnify2Task fork = new TypeUnify2Task(elems, eq, fc, parallel, logFile, log);
+				fork.fork();
+				res = fork.join();
+				*/
+				
+				Set<TypeUnifyTask> forks = new HashSet<>();
+				
+				//TypeUnify2Task fork1 = new TypeUnify2Task(elems, eq, fc, parallel, logFile, log);
+				
+				
+					Set<UnifyPair> newEqOrig = new HashSet<>(eq);
+					Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
+					newElemsOrig.add(a);
+					TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, fc, parallel, logFile, log);
+					forks.add(forkOrig);
+					forkOrig.fork();
+				
+				while (!nextSetasListRest.isEmpty()) {
+					Set<UnifyPair> nSaL = nextSetasListRest.remove(0);
+					Set<UnifyPair> newEq = new HashSet<>(eq);
+					Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
+					newElems.add(nSaL);
+					TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, fc, parallel, logFile, log);
+					forks.add(fork);
+					fork.fork();
+				}
+				//res = unify2(elems, eq, fc, parallel);
+				res = forkOrig.join();
+				for(TypeUnifyTask fork : forks) {
+					Set<Set<UnifyPair>> fork_res = fork.join();
+					add_res.add(fork_res);
+				}
+				
+			}
+			else {
+				elems.add(a);
+				res = unify2(elems, eq, fc, parallel);
+			}
 				if (!isUndefinedPairSetSet(res) && isUndefinedPairSetSet(result)) {
 					//wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
 					result = res;
+					if (res.iterator().next() instanceof WildcardType) {
+						System.out.println("");
+					}
 				}
 				else { 
 					if ((isUndefinedPairSetSet(res) && isUndefinedPairSetSet(result))
 					    || (!isUndefinedPairSetSet(res) && !isUndefinedPairSetSet(result))
 					    || result.isEmpty()) {
 						//alle Fehlerfaelle und alle korrekten Ergebnis jeweils adden
+						writeLog("RESADD:" + result.toString() + " " + res.toString());
 						result.addAll(res);
 					}
 					//else {
@@ -516,12 +596,36 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				//result.addAll(computeCartesianRecursive(elems, remainingSets, eq, fc, parallel)); 
 			//}
 				
-			/* auskommentiert um alle Loesungen zu bekommen ANFANG
+			/* auskommentiert um alle Max und min Betrachtung auszuschalten ANFANG */
 			if (!result.isEmpty() && !isUndefinedPairSetSet(res)) {
 				if (nextSetasList.iterator().hasNext() && nextSetasList.iterator().next().stream().filter(x -> x.getLhsType().getName().equals("D")).findFirst().isPresent() && nextSetasList.size()>1) 
 					System.out.print("");
 				Iterator<Set<UnifyPair>> nextSetasListIt = new ArrayList<Set<UnifyPair>>(nextSetasList).iterator(); 
 				if (variance == 1) {
+					if (parallel) {
+						for (Set<Set<UnifyPair>> par_res : add_res) {
+							if (!isUndefinedPairSetSet(par_res) && isUndefinedPairSetSet(result)) {
+								//wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
+								result = par_res;
+								if (par_res.iterator().next() instanceof WildcardType) {
+									System.out.println("");
+								}
+							}
+							else { 
+								if ((isUndefinedPairSetSet(par_res) && isUndefinedPairSetSet(result))
+										|| (!isUndefinedPairSetSet(par_res) && !isUndefinedPairSetSet(result))
+										|| result.isEmpty()) {
+									//alle Fehlerfaelle und alle korrekten Ergebnis jeweils adden
+									writeLog("RESADD:" + result.toString() + " " + par_res.toString());
+									result.addAll(par_res);
+								}
+							}
+						}
+						break;
+					}
+					/* nextSetasList = nextSetasListRest; */
+					/* wird bereits vor den unify2-Aufruf durchgefuehrt und nextSetasListRest zugeordnet
+					*/
 					System.out.println("");
 					while (nextSetasListIt.hasNext()) {
 						Set<UnifyPair> a_next = nextSetasListIt.next();
@@ -530,6 +634,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 							nextSetasList.remove(a_next);
 						}
 					}
+					
+					
 				}
 				else { if (variance == -1) {
 					System.out.println("");
@@ -546,6 +652,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				}
 				}
 			}
+			 /* auskommentiert um alle Max und min Betrachtung auszuschalten ENDE */ 
+			 
 			if (isUndefinedPairSetSet(res)) {
 				Set<UnifyPair> abhSubst = res.stream()
 							   .map(b -> 
@@ -586,8 +694,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			//	result.removeIf(y -> isUndefinedPairSet(y));
 			//}
 			//else result.stream().filter(y -> !isUndefinedPairSet(y));
-			 * auskommentiert um alle Loesungen zu bekommen ENDE
-			 */
 		}
 		return result;
 	}
@@ -1129,8 +1235,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				allGen = false;
 				break;
 			}
-		
+		Set<UnifyType> fBounded = new HashSet<>(pair.getfBounded());
-		for(UnifyType thetaS : fc.greater(theta, pair.getfBounded())) {
+		for(UnifyType thetaS : fc.greater(theta, fBounded/*pair.getfBounded()*/)) {
 			Set<UnifyPair> resultPrime = new HashSet<>();
 			Match match = new Match();
 			
@@ -1138,7 +1244,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			for(int i = 0; !allGen && i < freshTphs.length; i++) {
 				freshTphs[i] = PlaceholderType.freshPlaceholder();
 				((PlaceholderType)freshTphs[i]).setVariance(((PlaceholderType)a).getVariance());
-				Set<UnifyType> fBounded = pair.getfBounded();
+				//Set<UnifyType> fBounded = pair.getfBounded();
 			
 				int i_ef = i;
 				BiFunction<Boolean,UnifyType,Boolean> f = (x,y) -> 
@@ -1242,6 +1348,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	void writeLog(String str) {
 		if (log) {
 			try {
+				logFile.write("Thread no.:" + thNo + "\n");
 				logFile.write(str+"\n");
 				logFile.flush();
 			

test/bytecode/FacultyTest.java

@@ -0,0 +1,44 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class FacultyTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Faculty.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		compiler.generateBytecode(pathToClassFile);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Fac");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method getFac = classToTest.getDeclaredMethod("getFac", Integer.class);
+		Integer result = (Integer) getFac.invoke(instanceOfClass,3);
+		assertEquals(result, 6);
+	}
+
+}

test/bytecode/LambdaTest.java

@@ -1,6 +1,12 @@
 package bytecode;
 
+import static org.junit.Assert.assertEquals;
+
 import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
 
 import org.junit.Test;
 
@@ -10,6 +16,10 @@ public class LambdaTest {
 	private static String path;
 	private static File fileToTest;
 	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
 	
 	@Test
 	public void generateBC() throws Exception {
@@ -17,6 +27,20 @@ public class LambdaTest {
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode(System.getProperty("user.dir")+"/testBytecode/generatedBC/");
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Lambda");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+
+		Method m = classToTest.getDeclaredMethod("m");
+		Class<?> lambda = m.invoke(instanceOfClass).getClass();
+		Method apply = lambda.getMethod("apply", Object.class);
+		apply.setAccessible(true);
+
+		Integer i = 77;
+		// result = 77*77 = 5929
+		Integer result = (Integer) apply.invoke(m.invoke(instanceOfClass), i); 
+		assertEquals(5929, result);
 	}
 
 

test/bytecode/MatrixTest.java

@@ -3,8 +3,12 @@ package bytecode;
 import static org.junit.Assert.*;
 
 import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.Vector;
 
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -18,23 +22,72 @@ public class MatrixTest {
 	private static ClassLoader loader;
 	private static Class<?> classToTest;
 	private static String pathToClassFile;
-	private static Object instanceOfClass;
+	private static Object instanceOfClass_m1;
-	
+	private static Object instanceOfClass_m2;
-	@BeforeClass
+	private static Object instanceOfClass_m3;
-	public static void setUpBeforeClass() throws Exception {
+
+	@Test
+	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException, IOException, InstantiationException {	
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Matrix.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
-		classToTest = loader.loadClass("Matrix");
+		classToTest = loader.loadClass("Matrix"); 
-		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+		
-	}
+		instanceOfClass_m1 = classToTest.getDeclaredConstructor().newInstance(); //Matrix m1 = new Matrix();
+		//Vector<Vector<Integer>> vv = new Vector<Vector<Integer>>();
+		Vector<Integer> v1 = new Vector<Integer> ();
+		v1.addElement(2);
+		v1.addElement(2);
+		Vector<Integer> v2 = new Vector<Integer> ();
+		v2.addElement(3);
+		v2.addElement(3);
+		//Method[] ms = classToTest.getSuperclass().getDeclaredMethods();
+		Method addElement = classToTest.getSuperclass().getDeclaredMethod("addElement", Object.class);
+		addElement.invoke(instanceOfClass_m1, v1); //m1.addElement(v1);
+		addElement.invoke(instanceOfClass_m1, v2); //m1.addElement(v2);
+		//vv.addElement(v1);
+		//vv.addElement(v2);
+		//instanceOfClass_m1 = classToTest.getDeclaredConstructor(Vector.class).newInstance(vv);  //Matrix m1 = new Matrix(vv);
+		
+		Vector<Vector<Integer>> vv1 = new Vector<Vector<Integer>>();
+		Vector<Integer> v3 = new Vector<Integer> ();
+		v3.addElement(2);
+		v3.addElement(2);
+		Vector<Integer> v4 = new Vector<Integer> ();
+		v4.addElement(3);
+		v4.addElement(3);
+		//Matrix m2 = new Matrix();
+		//m2.addElement(v3);
+		//m2.addElement(v4);
+		vv1.addElement(v3);
+		vv1.addElement(v4);
+		instanceOfClass_m2 = classToTest.getDeclaredConstructor(Vector.class).newInstance(vv1);//Matrix m2 = new Matrix(vv1);
+		
+		 
 
-	@Test
+		//Matrix m3 = m1.mul(vv1);
-	public void test() {
+		Method mul = classToTest.getDeclaredMethod("mul", Vector.class);
-		fail("Not yet implemented");
+		Object result = mul.invoke(instanceOfClass_m1, instanceOfClass_m2);
+		System.out.println(instanceOfClass_m1.toString() + " * " + instanceOfClass_m1.toString() + " = " + result.toString());
+			
+		Vector<Vector<Integer>> res = new Vector<Vector<Integer>>();
+		Vector<Integer> v5 = new Vector<Integer> ();
+		v5.addElement(10);
+		v5.addElement(10);
+		Vector<Integer> v6 = new Vector<Integer> ();
+		v6.addElement(15);
+		v6.addElement(15);
+		//Matrix m2 = new Matrix();
+		//m2.addElement(v3);
+		//m2.addElement(v4);
+		res.addElement(v5);
+		res.addElement(v6);
+		instanceOfClass_m3 = classToTest.getDeclaredConstructor(Vector.class).newInstance(res);
+		assertEquals(result, instanceOfClass_m3);
+		
 	}
 
 }

test/bytecode/OLTest.java

@@ -3,6 +3,8 @@ package bytecode;
 import static org.junit.Assert.*;
 
 import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 
@@ -17,8 +19,10 @@ public class OLTest {
 	private static JavaTXCompiler compiler;
 	private static ClassLoader loader;
 	private static Class<?> classToTest;
+	private static Class<?> classToTest1;
 	private static String pathToClassFile;
 	private static Object instanceOfClass;
+	private static Object instanceOfClass1;
 	
 	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
@@ -30,10 +34,59 @@ public class OLTest {
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("OL");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+		classToTest1 = loader.loadClass("OLMain");
+		instanceOfClass1 = classToTest1.getDeclaredConstructor().newInstance();
 	}
+	
 	@Test
-	public void test() {
+	public void testOLClassName() {
-		fail("Not yet implemented");
+		assertEquals("OL", classToTest.getName());
+	}
+	
+	@Test
+	public void testmInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m", Integer.class);
+		Integer result = (Integer) m.invoke(instanceOfClass, 5);
+		assertEquals(10, result);
+	}
+	
+	@Test
+	public void testmDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m", Double.class);
+		Double result = (Double) m.invoke(instanceOfClass, 5.0);
+		assertEquals(10.0, result);
+	}
+	
+	@Test
+	public void testmString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m", String.class);
+		String result = (String) m.invoke(instanceOfClass, "xxx");
+		assertEquals("xxxxxx", result);
+	}
+	
+	@Test
+	public void testOLMainClassName() {
+		assertEquals("OLMain", classToTest1.getName());
+	}
+	
+	@Test
+	public void testmainInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method main = classToTest1.getDeclaredMethod("main", Integer.class);
+		Integer result = (Integer) main.invoke(instanceOfClass1, 5);
+		assertEquals(10, result);
+	}
+	
+	@Test
+	public void testmainDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method main = classToTest1.getDeclaredMethod("main", Double.class);
+		Double result = (Double) main.invoke(instanceOfClass1, 5.0);
+		assertEquals(10.0, result);
+	}
+	
+	@Test
+	public void testmainString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method main = classToTest1.getDeclaredMethod("main", String.class);
+		String result = (String) main.invoke(instanceOfClass1, "xxx");
+		assertEquals("xxxxxx", result);
 	}
-
 }

test/bytecode/SubMatTest.java

@@ -0,0 +1,27 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class SubMatTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static String pathToClassFile;
+	
+	@Test
+	public void test() throws ClassNotFoundException, IOException {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/SubMatrix.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+	}
+
+}

test/bytecode/Tph2Test.java

@@ -3,6 +3,7 @@ package bytecode;
 import static org.junit.Assert.*;
 
 import java.io.File;
+import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 
@@ -34,8 +35,35 @@ public class Tph2Test {
 	}
 
 	@Test
-	public void test() {
+	public void test1() throws Exception {
-		fail("Not yet implemented");
+		Method m = classToTest.getDeclaredMethod("m", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, 1,2);
+		
+		assertEquals(1,result);
+	}
+	
+	@Test
+	public void test2() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, "sss",2);
+		
+		assertEquals("sss",result);
+	}
+	
+	@Test
+	public void test3() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m2", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, 1,2);
+		
+		assertEquals(2,result);
+	}
+	
+	@Test
+	public void test4() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m2", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, 1,"xxx");
+		
+		assertEquals("xxx",result);
 	}
 
 }

test/bytecode/Tph3Test.java

@@ -0,0 +1,69 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class Tph3Test {
+	
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Tph3.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Tph2");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test1() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, 1,2);
+		
+		assertEquals(1,result);
+	}
+	
+	@Test
+	public void test2() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, "sss",2);
+		
+		assertEquals("sss",result);
+	}
+	
+	@Test
+	public void test3() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m2", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, 1,2);
+		
+		assertEquals(2,result);
+	}
+	
+	@Test
+	public void test4() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m2", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, 1,"xxx");
+		
+		assertEquals("xxx",result);
+	}
+
+}

test/bytecode/TphTest.java

@@ -3,6 +3,7 @@ package bytecode;
 import static org.junit.Assert.*;
 
 import java.io.File;
+import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 
@@ -12,6 +13,7 @@ import org.junit.Test;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 
 public class TphTest {
+	
 	private static String path;
 	private static File fileToTest;
 	private static JavaTXCompiler compiler;
@@ -33,8 +35,35 @@ public class TphTest {
 	}
 
 	@Test
-	public void test() {
+	public void test1() throws Exception {
-		fail("Not yet implemented");
+		Method m = classToTest.getDeclaredMethod("m", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, 1,2);
+		
+		assertEquals(2,result);
+	}
+	
+	@Test
+	public void test2() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m", Object.class, Object.class);
+		Object result = m.invoke(instanceOfClass, 1, "sss");
+		
+		assertEquals("sss",result);
+	}
+	
+	@Test
+	public void test3() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m2", Object.class);
+		Object result = m.invoke(instanceOfClass, 2);
+		
+		assertEquals(2,result);
+	}
+	
+	@Test
+	public void test4() throws Exception {
+		Method m = classToTest.getDeclaredMethod("m2", Object.class);
+		Object result = m.invoke(instanceOfClass,"xxx");
+		
+		assertEquals("xxx",result);
 	}
 
 }

test/bytecode/applyLambdaTest.java

@@ -0,0 +1,39 @@
+package bytecode;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class applyLambdaTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@Test
+	public void generateBC() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/applyLambda.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		compiler.generateBytecode(System.getProperty("user.dir")+"/testBytecode/generatedBC/");
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("applyLambda");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+
+		Method m = classToTest.getDeclaredMethod("m");
+		Object result = m.invoke(instanceOfClass);
+		
+		assertEquals(result.getClass(), loader.loadClass("Apply"));
+	}
+}

test/bytecode/javFiles/Lambda.jav

@@ -1,15 +1,11 @@
-import java.util.Vector;
+import java.lang.Integer;
-class Apply { } 
 
 public class Lambda {
 
   m () {
-   var lam1 = (x) -> {
+   var lam1 = (Integer x) -> {
-        return x;
+        return x * x;
    };
-	return lam1.apply(new Apply());
+   return lam1;
-   //return lam1;
-//   return new Vector();
   }
 }
-

test/bytecode/javFiles/Matrix.jav

@@ -1,26 +1,42 @@
 import java.util.Vector;
 import java.lang.Integer;
+//import java.lang.Byte;
 import java.lang.Boolean;
 
 public class Matrix extends Vector<Vector<Integer>> {
-    mul(m) {
+   
+	Matrix () {
+    }
+
+	Matrix(vv) {
+    	Integer i;
+    	i = 0;
+	  while(i < vv.size()) {
+//	    	Boolean a = this.add(vv.elementAt(i));
+		  this.add(vv.elementAt(i));
+		  i=i+1;
+	  }
+    }
+
+	mul(m) {
         var ret = new Matrix();
         var i = 0;
         while(i < size()) {
             var v1 = this.elementAt(i);
-//            var v2 = new Vector<Integer>();
+            var v2 = new Vector<Integer>();
-//            var j = 0;
+            var j = 0;
-//            while(j < v1.size()) {
+            while(j < v1.size()) {
-//                var erg = 0;
+                var erg = 0;
- //               var k = 0;
+                var k = 0;
-  //              while(k < v1.size()) {
+                while(k < v1.size()) {
-//                    erg = erg + v1.elementAt(k)
+                    erg = erg + v1.elementAt(k)
- //                            * m.elementAt(k).elementAt(j);
+                             * m.elementAt(k).elementAt(j);
-   //                 k++; }
+                    k++; }
-    //            v2.addElement(new Integer(erg));
+//                v2.addElement(new Integer(erg));
-//                j++; }
+                v2.addElement(erg);
-//            ret.addElement(v2);
+                j++; }
-//            i++; 
+            ret.addElement(v2);
+            i++; 
          }
         return ret;
     }

test/bytecode/javFiles/OL.jav

@@ -1,10 +1,11 @@
+import java.lang.String;
 import java.lang.Integer;
 import java.lang.Double;  
 
 
-class OL  {
+public class OL   {
 
-    m(java.lang.Double x) { return x + x; }
+    m(x) { return x + x; }
 	
     //m(x) { return x || x; } 
 	 
@@ -12,7 +13,7 @@ class OL  {
 	}
    
          
-class Main {
+public class OLMain {
 
 	main(x) { 
 		var ol;

test/bytecode/javFiles/SubMatrix.jav

@@ -0,0 +1,13 @@
+import java.util.Vector;
+import java.lang.Integer;
+
+public class Matrix2 extends Vector<Integer> {
+	
+}
+
+public class SubMatrix extends Matrix2 {
+	m(){
+		Vector<Integer> v = new Vector<Integer>();
+		v.add(1);
+	}
+}

test/bytecode/javFiles/Tph.jav

@@ -2,7 +2,7 @@ public class Tph {
 	
 	m(a,b){
 		var c = m2(b);
-		return a;
+		return c;
 	}
 	
 	m2(b){

test/bytecode/javFiles/Tph3.jav

@@ -0,0 +1,10 @@
+public class Tph3 {
+	m(a,b){
+		var c = m2(a,b);
+		return c;
+	}
+	
+	m2(a,b){
+		return m(a,b);
+	}
+}

test/bytecode/javFiles/applyLambda.jav

@@ -0,0 +1,16 @@
+import java.util.Vector;
+class Apply { } 
+
+public class applyLambda {
+
+  m () {
+   var lam1 = (x) -> {
+        return x;
+   };
+
+   //return lam1.apply(new Apply());
+   return lam1;
+   //return new Vector();
+  }
+}
+

test/javFiles/Matrix.jav

@@ -15,9 +15,9 @@ class Matrix extends Vector<Vector<Integer>> {
                 var erg = 0;
                 var k = 0;
                 while(k < v1.size()) {
-                  //erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
+                  erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
-                    erg = add1(erg, mul1(v1.elementAt(k),
+                  //erg = add1(erg, mul1(v1.elementAt(k),
-                             m.elementAt(k).elementAt(j)));
+                  //           m.elementAt(k).elementAt(j)));
                     k++; }
                 v2.addElement(new Integer(erg));
                 j++; }