i21023/JavaTXCompilerInJavaTX
2
0
Fork 0
forked from JavaTX/JavaCompilerCore
Code Pull Requests Activity

Bugs gefixt. Tests für relationalen Operatoren(GreaterEqualTest, ...) laufen.

Browse Source 
Für Typplaceholder werden Generics verwendet.

Neue Tests angefügt.
This commit is contained in:
Fayez Abu Alia 2018-05-23 15:38:41 +02:00
parent dcc36f082f
commit 0f29bc038a
19 changed files with 467 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/de/dhbwstuttgart/bytecode/BytecodeGen.java
View File

@ -117,7 +117,7 @@ public class BytecodeGen implements ASTVisitor {
boolean isConsWithNoParamsVisited = false; boolean isConsWithNoParamsVisited = false;
for(ResultSet rs : listOfResultSets) { for(ResultSet rs : listOfResultSets) {
resultSet = rs; resultSet = rs;
for(Constructor c : classOrInterface.getConstructors()) { for(Constructor c : classOrInterface.getConstructors()) {
if(!isConsWithNoParamsVisited) if(!isConsWithNoParamsVisited)
c.accept(this); c.accept(this);
@ -191,13 +191,13 @@ public class BytecodeGen implements ASTVisitor {
System.out.println(acc); System.out.println(acc);
/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/ /*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
boolean hasGenInParameterList = genericsAndBounds.containsKey(resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())); boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.subSequence(0, 4).equals("TPH ");
/*Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature, wenn nicht, /*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*/ * prüfe, ob einer der Parameter Typ-Variable als Typ hat*/
if(!hasGenInParameterList) { if(!hasGenInParameterList) {
for(String paramName : methodParamsAndTypes.keySet()) { for(String paramName : methodParamsAndTypes.keySet()) {
String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor()); String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
if(genericsAndBounds.containsKey(typeOfParam)) { if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.substring(0, 4).equals("TPH ")) {
hasGenInParameterList = true; hasGenInParameterList = true;
break; break;
} }
@ -213,6 +213,7 @@ public class BytecodeGen implements ASTVisitor {
boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList; boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList;
/* if method has generics or return type is TPH, create signature */ /* 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||method.getReturnType().acceptTV(new TypeToString()).equals("TPH")) {
// resultset hier zum testen // resultset hier zum testen
Signature signature = new Signature(method, genericsAndBoundsMethod, methodParamsAndTypes,resultSet); Signature signature = new Signature(method, genericsAndBoundsMethod, methodParamsAndTypes,resultSet);

220
src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
View File

@ -29,8 +29,6 @@ import org.objectweb.asm.signature.SignatureWriter;
import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString; import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor; import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
import de.dhbwstuttgart.bytecode.signature.Signature; import de.dhbwstuttgart.bytecode.signature.Signature;
import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
import de.dhbwstuttgart.bytecode.signature.TypeToString;
import de.dhbwstuttgart.bytecode.utilities.KindOfLambda; import de.dhbwstuttgart.bytecode.utilities.KindOfLambda;
import de.dhbwstuttgart.bytecode.utilities.Lambda; import de.dhbwstuttgart.bytecode.utilities.Lambda;
import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall; import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
@ -55,20 +53,17 @@ public class BytecodeGenMethod implements StatementVisitor {
HashMap<String, String> genericsAndBoundsMethod; HashMap<String, String> genericsAndBoundsMethod;
private HashMap<String, String> genericsAndBounds; private HashMap<String, String> genericsAndBounds;
private boolean isBinaryExp = false; private boolean isBinaryExp = false;
private IStatement statement; private IStatement statement = null;
// for tests ** // for tests **
private String fieldName; private String fieldName;
private String fieldDesc; private String fieldDesc;
private Expression rightSideTemp; private Expression rightSideTemp;
private boolean isRightSideALambda = false; private boolean isRightSideALambda = false;
private KindOfLambda kindOfLambda; private KindOfLambda kindOfLambda;
private HashMap<String, byte[]> classFiles; private HashMap<String, byte[]> classFiles;
private boolean isAssignStmt = false;
private Statement loopBlock;
private ArrayList<RefTypeOrTPHOrWildcardOrGeneric> varsFunInterface = new ArrayList<>();; private ArrayList<RefTypeOrTPHOrWildcardOrGeneric> varsFunInterface = new ArrayList<>();;
@ -113,7 +108,7 @@ public class BytecodeGenMethod implements StatementVisitor {
private String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) { private String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor()); return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor());
} }
@Override @Override
public void visit(Block block) { public void visit(Block block) {
for (Statement stmt : block.getStatements()) { for (Statement stmt : block.getStatements()) {
@ -138,7 +133,7 @@ public class BytecodeGenMethod implements StatementVisitor {
mv.visitVarInsn(Opcodes.ALOAD, paramsAndLocals.get(localVar.name)); mv.visitVarInsn(Opcodes.ALOAD, paramsAndLocals.get(localVar.name));
if (isBinaryExp) { if (isBinaryExp) {
getVlaueIns(getResolvedType(localVar.getType())); doUnboxing(getResolvedType(localVar.getType()));
} }
} }
@ -151,8 +146,6 @@ public class BytecodeGenMethod implements StatementVisitor {
@Override @Override
public void visit(Assign assign) { public void visit(Assign assign) {
statement = new AssignStmt(assign.rightSide); statement = new AssignStmt(assign.rightSide);
isAssignStmt = true;
// if the right side is a lambda => the left side must be a functional interface // if the right side is a lambda => the left side must be a functional interface
if (assign.rightSide instanceof LambdaExpression) { if (assign.rightSide instanceof LambdaExpression) {
isRightSideALambda = true; isRightSideALambda = true;
@ -161,7 +154,6 @@ public class BytecodeGenMethod implements StatementVisitor {
} }
isBinaryExp = statement.isExprBinary(); isBinaryExp = statement.isExprBinary();
if (assign.lefSide instanceof AssignToField) { if (assign.lefSide instanceof AssignToField) {
// load_0, ldc or .. then putfield // load_0, ldc or .. then putfield
@ -171,26 +163,24 @@ public class BytecodeGenMethod implements StatementVisitor {
} }
if (isBinaryExp) { if (isBinaryExp) {
BinaryExpr binary = (BinaryExpr) assign.rightSide; BinaryExpr binary = (BinaryExpr) assign.rightSide;
String lexpType = getResolvedType(binary.lexpr.getType()); String binaryType = getResolvedType(binary.getType());
String rexpType = getResolvedType(binary.rexpr.getType()); doBoxing(binaryType);
getValueOfIns(getLargerType(lexpType, rexpType));
isBinaryExp = false; isBinaryExp = false;
} }
assign.lefSide.accept(this); assign.lefSide.accept(this);
isAssignStmt =false;
}
statement = null;
}
@Override @Override
public void visit(BinaryExpr binary) { public void visit(BinaryExpr binary) {
String lexpType = getResolvedType(binary.lexpr.getType()); String lexpType = getResolvedType(binary.lexpr.getType());
String rexpType = getResolvedType(binary.rexpr.getType()); String rexpType = getResolvedType(binary.rexpr.getType());
String largerType = getLargerType(lexpType,rexpType); String largerType = getLargerType(lexpType, rexpType);
String typeOfBinary = getResolvedType(binary.getType()); String typeOfBinary = getResolvedType(binary.getType());
if (typeOfBinary.equals(Type.getInternalName(String.class))) { if (typeOfBinary.equals(Type.getInternalName(String.class))) {
mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(StringBuilder.class)); mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(StringBuilder.class));
mv.visitInsn(Opcodes.DUP); mv.visitInsn(Opcodes.DUP);
@ -200,23 +190,21 @@ public class BytecodeGenMethod implements StatementVisitor {
Label endLabel = new Label(); Label endLabel = new Label();
// this case for while loops // this case for while loops
if(statement instanceof LoopStmt) if (statement instanceof LoopStmt)
mv.visitLabel(endLabel); mv.visitLabel(endLabel);
binary.lexpr.accept(this); binary.lexpr.accept(this);
if(!lexpType.equals(rexpType) && if (!lexpType.equals(rexpType) && !lexpType.equals(largerType))
!lexpType.equals(largerType))
doCast(lexpType, largerType); doCast(lexpType, largerType);
binary.rexpr.accept(this); binary.rexpr.accept(this);
if(!lexpType.equals(rexpType) && if (!lexpType.equals(rexpType) && !rexpType.equals(largerType))
!rexpType.equals(largerType))
doCast(rexpType, largerType); doCast(rexpType, largerType);
Operator op = binary.operation; Operator op = binary.operation;
switch (op) { switch (op) {
case ADD: case ADD:
doVisitAddOpInsn(largerType); doVisitAddOpInsn(largerType);
@ -243,28 +231,31 @@ public class BytecodeGenMethod implements StatementVisitor {
case BIGGERTHAN: case BIGGERTHAN:
case BIGGEREQUAL: case BIGGEREQUAL:
Label branchLabel = new Label(); Label branchLabel = new Label();
doVisitRelOpInsn(op,largerType, branchLabel, endLabel); doVisitRelOpInsn(op, largerType, branchLabel, endLabel);
break; break;
default: default:
break; break;
} }
} }
/*
* Diese Methode wird nicht mehr gebraucht, da es jetzt nicht möglich ist, dass
* solche Fälle: Integer -> Integer (OP) Short ,... usw, nicht vorkommen!
*/
private String getLargerType(String lexpType, String rexpType) { private String getLargerType(String lexpType, String rexpType) {
if(lexpType.equals(Type.getInternalName(String.class)) || if (lexpType.equals(Type.getInternalName(String.class))
rexpType.equals(Type.getInternalName(String.class))) { || rexpType.equals(Type.getInternalName(String.class))) {
return Type.getInternalName(String.class); return Type.getInternalName(String.class);
} else } else if (lexpType.equals(Type.getInternalName(Double.class))
if(lexpType.equals(Type.getInternalName(Double.class)) || || rexpType.equals(Type.getInternalName(Double.class))) {
rexpType.equals(Type.getInternalName(Double.class))) {
return Type.getInternalName(Double.class); return Type.getInternalName(Double.class);
} else if(lexpType.equals(Type.getInternalName(Float.class)) || } else if (lexpType.equals(Type.getInternalName(Float.class))
rexpType.equals(Type.getInternalName(Float.class))) { || rexpType.equals(Type.getInternalName(Float.class))) {
return Type.getInternalName(Float.class); return Type.getInternalName(Float.class);
} else if(lexpType.equals(Type.getInternalName(Long.class)) || } else if (lexpType.equals(Type.getInternalName(Long.class))
rexpType.equals(Type.getInternalName(Long.class))) { || rexpType.equals(Type.getInternalName(Long.class))) {
return Type.getInternalName(Long.class); return Type.getInternalName(Long.class);
} else { } else {
return Type.getInternalName(Integer.class); return Type.getInternalName(Integer.class);
@ -276,19 +267,19 @@ public class BytecodeGenMethod implements StatementVisitor {
case "java/lang/Long": case "java/lang/Long":
mv.visitInsn(Opcodes.I2L); mv.visitInsn(Opcodes.I2L);
break; break;
case "java/lang/Double": case "java/lang/Double":
if(sourceType.equals(Type.getInternalName(Long.class))) { if (sourceType.equals(Type.getInternalName(Long.class))) {
mv.visitInsn(Opcodes.L2D); mv.visitInsn(Opcodes.L2D);
} else if(sourceType.equals(Type.getInternalName(Float.class))) { } else if (sourceType.equals(Type.getInternalName(Float.class))) {
mv.visitInsn(Opcodes.F2D); mv.visitInsn(Opcodes.F2D);
} else { } else {
mv.visitInsn(Opcodes.I2D); mv.visitInsn(Opcodes.I2D);
} }
break; break;
case "java/lang/Float": case "java/lang/Float":
if(sourceType.equals(Type.getInternalName(Long.class))) { if (sourceType.equals(Type.getInternalName(Long.class))) {
mv.visitInsn(Opcodes.L2F); mv.visitInsn(Opcodes.L2F);
} else { } else {
mv.visitInsn(Opcodes.I2F); mv.visitInsn(Opcodes.I2F);
@ -296,14 +287,18 @@ public class BytecodeGenMethod implements StatementVisitor {
break; break;
// braucht man eigentlic nicht, muss getestet werden // braucht man eigentlic nicht, muss getestet werden
case "java/lang/String": case "java/lang/String":
if(sourceType.equals(Type.getInternalName(Double.class))) { if (sourceType.equals(Type.getInternalName(Double.class))) {
mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "valueOf", "(D)Ljava/lang/String;", false); mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "valueOf",
} else if(sourceType.equals(Type.getInternalName(Long.class))) { "(D)Ljava/lang/String;", false);
mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "valueOf", "(J)Ljava/lang/String;", false); } else if (sourceType.equals(Type.getInternalName(Long.class))) {
} else if(sourceType.equals(Type.getInternalName(Float.class))) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "valueOf",
mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "valueOf", "(F)Ljava/lang/String;", false); "(J)Ljava/lang/String;", false);
} else if (sourceType.equals(Type.getInternalName(Float.class))) {
mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "valueOf",
"(F)Ljava/lang/String;", false);
} else { } else {
mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "valueOf", "(I)Ljava/lang/String;", false); mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "valueOf",
"(I)Ljava/lang/String;", false);
} }
break; break;
default: default:
@ -312,7 +307,7 @@ public class BytecodeGenMethod implements StatementVisitor {
} }
private void doVisitRelOpInsn(Operator op, String typeOfBinary, Label branchLabel, Label endLabel) { private void doVisitRelOpInsn(Operator op, String typeOfBinary, Label branchLabel, Label endLabel) {
switch (typeOfBinary) { switch (typeOfBinary) {
case "java/lang/Long": case "java/lang/Long":
mv.visitInsn(Opcodes.LCMP); mv.visitInsn(Opcodes.LCMP);
@ -343,9 +338,9 @@ public class BytecodeGenMethod implements StatementVisitor {
default: default:
break; break;
} }
statement.genBCForRelOp(mv, branchLabel, endLabel,this); statement.genBCForRelOp(mv, branchLabel, endLabel, this);
break; break;
} }
} }
@ -368,8 +363,8 @@ public class BytecodeGenMethod implements StatementVisitor {
default: default:
break; break;
} }
statement.genBCForRelOp(mv, branchLabel, endLabel, this); statement.genBCForRelOp(mv, branchLabel, endLabel, this);
} }
private void doVisitModOpInsn(String typeOfBinary) { private void doVisitModOpInsn(String typeOfBinary) {
@ -532,7 +527,7 @@ public class BytecodeGenMethod implements StatementVisitor {
cw.visitInnerClass("java/lang/invoke/MethodHandles$Lookup", "java/lang/invoke/MethodHandles", "Lookup", cw.visitInnerClass("java/lang/invoke/MethodHandles$Lookup", "java/lang/invoke/MethodHandles", "Lookup",
Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC + Opcodes.ACC_FINAL); Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC + Opcodes.ACC_FINAL);
generateBCForFunN(lambdaExpression,typeErasure); generateBCForFunN(lambdaExpression, typeErasure);
} }
private void generateBCForFunN(LambdaExpression lambdaExpression, String methDesc) { private void generateBCForFunN(LambdaExpression lambdaExpression, String methDesc) {
@ -626,7 +621,7 @@ public class BytecodeGenMethod implements StatementVisitor {
@Override @Override
public void visit(MethodCall methodCall) { public void visit(MethodCall methodCall) {
methodCall.receiver.accept(this); methodCall.receiver.accept(this);
methodCall.arglist.accept(this); methodCall.arglist.accept(this);
@ -634,7 +629,7 @@ public class BytecodeGenMethod implements StatementVisitor {
genericsAndBoundsMethod, genericsAndBounds); genericsAndBoundsMethod, genericsAndBounds);
String mDesc = method.accept(new DescriptorToString(resultSet)); String mDesc = method.accept(new DescriptorToString(resultSet));
// is methodCall.receiver functional Interface)? // is methodCall.receiver functional Interface)?
if (varsFunInterface.contains(methodCall.receiver.getType())) { if (varsFunInterface.contains(methodCall.receiver.getType())) {
mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, getResolvedType(methodCall.receiver.getType()), methodCall.name, mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, getResolvedType(methodCall.receiver.getType()), methodCall.name,
mDesc, false); mDesc, false);
@ -650,7 +645,7 @@ public class BytecodeGenMethod implements StatementVisitor {
@Override @Override
public void visit(NewClass methodCall) { public void visit(NewClass methodCall) {
mv.visitTypeInsn(Opcodes.NEW, methodCall.name.replace(".", "/")); mv.visitTypeInsn(Opcodes.NEW, methodCall.name.replace(".", "/"));
mv.visitInsn(Opcodes.DUP); mv.visitInsn(Opcodes.DUP);
// creates Descriptor // creates Descriptor
@ -679,40 +674,40 @@ public class BytecodeGenMethod implements StatementVisitor {
public void visit(UnaryExpr unaryExpr) { public void visit(UnaryExpr unaryExpr) {
unaryExpr.expr.accept(this); unaryExpr.expr.accept(this);
Operation op = unaryExpr.operation; Operation op = unaryExpr.operation;
String typeOfUnary = getResolvedType(unaryExpr.getType()); String typeOfUnary = getResolvedType(unaryExpr.getType());
boolean isIncOrDec = false; boolean isIncOrDec = false;
switch (op) { switch (op) {
case POSTDECREMENT: case POSTDECREMENT:
case POSTINCREMENT: case POSTINCREMENT:
if(isAssignStmt) if (statement instanceof AssignStmt)
mv.visitInsn(Opcodes.DUP); mv.visitInsn(Opcodes.DUP);
genBCForIncAndDec(op, typeOfUnary); genBCForIncAndDec(op, typeOfUnary);
getValueOfIns(typeOfUnary); doBoxing(typeOfUnary);
isIncOrDec = true; isIncOrDec = true;
break; break;
case PREDECREMENT: case PREDECREMENT:
case PREINCREMENT: case PREINCREMENT:
genBCForIncAndDec(op, typeOfUnary); genBCForIncAndDec(op, typeOfUnary);
getValueOfIns(typeOfUnary); doBoxing(typeOfUnary);
if(isAssignStmt) if (statement instanceof AssignStmt)
mv.visitInsn(Opcodes.DUP); mv.visitInsn(Opcodes.DUP);
isIncOrDec = true; isIncOrDec = true;
break; break;
case MINUS: case MINUS:
doVisitNegIns(typeOfUnary); doVisitNegIns(typeOfUnary);
break; break;
default: default:
break; break;
} }
// Für Byte und Short muss noch einen Cast geben i2b, i2s // Für Byte und Short muss noch einen Cast geben i2b, i2s
// das wird später gemacht, da bytecode für cast noch nicht erzeugt wird // das wird später gemacht, da bytecode für cast noch nicht erzeugt wird
if(isIncOrDec && (unaryExpr.expr instanceof LocalVar)) { if (isIncOrDec && (unaryExpr.expr instanceof LocalVar)) {
LocalVar local = (LocalVar) unaryExpr.expr; LocalVar local = (LocalVar) unaryExpr.expr;
mv.visitVarInsn(Opcodes.ASTORE, paramsAndLocals.get(local.name)); mv.visitVarInsn(Opcodes.ASTORE, paramsAndLocals.get(local.name));
} }
@ -733,14 +728,14 @@ public class BytecodeGenMethod implements StatementVisitor {
mv.visitInsn(Opcodes.INEG); mv.visitInsn(Opcodes.INEG);
break; break;
} }
} }
private void genBCForIncAndDec(Operation op, String typeOfUnary) { private void genBCForIncAndDec(Operation op, String typeOfUnary) {
getVlaueIns(typeOfUnary); doUnboxing(typeOfUnary);
doAssign(typeOfUnary, 1.0, true); loadValue(typeOfUnary, 1.0, true);
switch (op) { switch (op) {
case POSTDECREMENT: case POSTDECREMENT:
case PREDECREMENT: case PREDECREMENT:
@ -751,7 +746,7 @@ public class BytecodeGenMethod implements StatementVisitor {
case PREINCREMENT: case PREINCREMENT:
doVisitAddOpInsn(typeOfUnary); doVisitAddOpInsn(typeOfUnary);
break; break;
default: default:
break; break;
} }
@ -759,22 +754,19 @@ public class BytecodeGenMethod implements StatementVisitor {
@Override @Override
public void visit(Return aReturn) { public void visit(Return aReturn) {
statement = new ReturnStmt(aReturn.retexpr); statement = new ReturnStmt(aReturn.retexpr);
isBinaryExp = statement.isExprBinary(); isBinaryExp = statement.isExprBinary();
aReturn.retexpr.accept(this); aReturn.retexpr.accept(this);
if (isBinaryExp) { if (isBinaryExp) {
BinaryExpr binary = (BinaryExpr) aReturn.retexpr; BinaryExpr binary = (BinaryExpr) aReturn.retexpr;
String lexpType = getResolvedType(binary.lexpr.getType()); doBoxing(getResolvedType(binary.getType()));
String rexpType = getResolvedType(binary.rexpr.getType());
getValueOfIns(getLargerType(lexpType, rexpType));
isBinaryExp = false; isBinaryExp = false;
} }
mv.visitInsn(Opcodes.ARETURN); mv.visitInsn(Opcodes.ARETURN);
statement = null;
} }
@Override @Override
@ -787,7 +779,8 @@ public class BytecodeGenMethod implements StatementVisitor {
// mv.visitMethodInsn(Opcodes.INVOKESTATIC, // mv.visitMethodInsn(Opcodes.INVOKESTATIC,
// staticClassName.getType().toString().replace(".", "/"), // staticClassName.getType().toString().replace(".", "/"),
// staticClassName.toString(), staticClassName.getType().toString(), false); // staticClassName.toString(), staticClassName.getType().toString(), false);
//mv.visitFieldInsn(Opcodes.GETSTATIC, getResolvedType(staticClassName.getType()), fieldName, fieldDesc); // mv.visitFieldInsn(Opcodes.GETSTATIC,
// getResolvedType(staticClassName.getType()), fieldName, fieldDesc);
throw new NotImplementedException("Static noch nicht implementiert!"); throw new NotImplementedException("Static noch nicht implementiert!");
} }
@ -803,16 +796,11 @@ public class BytecodeGenMethod implements StatementVisitor {
@Override @Override
public void visit(WhileStmt whileStmt) { public void visit(WhileStmt whileStmt) {
statement = new LoopStmt(whileStmt.expr, whileStmt.loopBlock); statement = new LoopStmt(whileStmt.expr, whileStmt.loopBlock);
this.loopBlock = whileStmt.loopBlock;
isBinaryExp = statement.isExprBinary(); isBinaryExp = statement.isExprBinary();
whileStmt.expr.accept(this); whileStmt.expr.accept(this);
isBinaryExp = false; isBinaryExp = false;
statement = null;
} }
@Override @Override
@ -825,12 +813,13 @@ public class BytecodeGenMethod implements StatementVisitor {
public void visit(Literal literal) { public void visit(Literal literal) {
Object value = literal.value; Object value = literal.value;
String typeOfLiteral = getResolvedType(literal.getType()); String typeOfLiteral = getResolvedType(literal.getType());
// Name der Methode muss geändert werden // Der Wert des Literals wird auf den Stack geladen und
doAssign(typeOfLiteral, value, false); // geboxt, wenn es nötig ist.
loadValue(typeOfLiteral, value, false);
} }
private void getVlaueIns(String type) { // Unboxing: RefType -> prim
private void doUnboxing(String type) {
switch (type) { switch (type) {
case "java/lang/String": case "java/lang/String":
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(StringBuilder.class), "append", mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(StringBuilder.class), "append",
@ -860,11 +849,13 @@ public class BytecodeGenMethod implements StatementVisitor {
case "java/lang/Character": case "java/lang/Character":
break; break;
default: default:
// mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Integer", "intValue",
// "()I", false);
break; break;
} }
} }
private void doAssign(String type, Object value, boolean isOperator) { private void loadValue(String type, Object value, boolean isOperator) {
switch (type) { switch (type) {
case "java/lang/String": case "java/lang/String":
mv.visitLdcInsn(String.valueOf(value)); mv.visitLdcInsn(String.valueOf(value));
@ -895,17 +886,21 @@ public class BytecodeGenMethod implements StatementVisitor {
visitCharLiteral((Character) value); visitCharLiteral((Character) value);
break; break;
default: default:
// wenn die Typ des Literals = Number ist, wird integer-value
// verwendet
// visitIntegerLiteral(((Double) value).intValue(), false);
break; break;
} }
// Boxing
if(!type.equals("java/lang/String")&&!type.equals("java/lang/Boolean")) { if (!type.equals("java/lang/String") && !type.equals("java/lang/Boolean")) {
if (!this.isBinaryExp && !isOperator) if (!this.isBinaryExp && !isOperator)
getValueOfIns(type); doBoxing(type);
} }
} }
private void getValueOfIns(String type) { // Boxing: prim -> RefType
private void doBoxing(String type) {
switch (type) { switch (type) {
case "java/lang/String": case "java/lang/String":
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;",
@ -943,7 +938,7 @@ public class BytecodeGenMethod implements StatementVisitor {
private void visitCharLiteral(Character value) { private void visitCharLiteral(Character value) {
mv.visitIntInsn(Opcodes.BIPUSH, (int) value); mv.visitIntInsn(Opcodes.BIPUSH, (int) value);
} }
private void visitDoubleLiteral(Double value) { private void visitDoubleLiteral(Double value) {
@ -1019,6 +1014,7 @@ public class BytecodeGenMethod implements StatementVisitor {
for (Expression al : argumentList.getArguments()) { for (Expression al : argumentList.getArguments()) {
statement = new ArgumentExpr(al); statement = new ArgumentExpr(al);
al.accept(this); al.accept(this);
statement = null;
} }
} }
@ -1042,12 +1038,12 @@ public class BytecodeGenMethod implements StatementVisitor {
varsFunInterface.add(assignLeftSide.localVar.getType()); varsFunInterface.add(assignLeftSide.localVar.getType());
int index = paramsAndLocals.size(); int index = paramsAndLocals.size();
String var = assignLeftSide.localVar.name; String var = assignLeftSide.localVar.name;
if(!paramsAndLocals.containsKey(var)) { if (!paramsAndLocals.containsKey(var)) {
paramsAndLocals.put(var, index + 1); paramsAndLocals.put(var, index + 1);
}else { } else {
paramsAndLocals.put(var, index); paramsAndLocals.put(var, index);
} }
mv.visitVarInsn(Opcodes.ASTORE, paramsAndLocals.size()); mv.visitVarInsn(Opcodes.ASTORE, paramsAndLocals.size());
// Debug::: // Debug:::

17
src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
View File

@ -46,12 +46,18 @@ public class DescriptorToString implements DescriptorVisitor{
}else if(method.getGenericsAndBounds().containsKey(fpDesc)){ }else if(method.getGenericsAndBounds().containsKey(fpDesc)){
desc += "L"+method.getGenericsAndBounds().get(fpDesc)+ ";"; desc += "L"+method.getGenericsAndBounds().get(fpDesc)+ ";";
}else { }else {
desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";"; // desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
String resType = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
if(resType.subSequence(0, 4).equals("TPH ")) {
desc += "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
} else {
desc += "L"+resType+ ";";
}
} }
} }
//TODO: generate a class java%% ... %% //TODO: generate a class java%% ... %%
else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains("<")){ else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains("<")){
desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "%").replace("<", "%%").replace(">", "%%")+ ";"; desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "$$").replace("<", "$$$").replace(">", "$$$")+ ";";
} }
else { else {
desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";"; desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
@ -68,7 +74,12 @@ public class DescriptorToString implements DescriptorVisitor{
}else if(method.getGenericsAndBounds().containsKey(ret)){ }else if(method.getGenericsAndBounds().containsKey(ret)){
desc += ")L"+method.getGenericsAndBounds().get(ret)+ ";"; desc += ")L"+method.getGenericsAndBounds().get(ret)+ ";";
}else { }else {
desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";"; String resType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
if(resType.subSequence(0, 4).equals("TPH ")) {
desc += ")" + "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
} else {
desc += ")" + "L"+resType+ ";";
}
} }
}else { }else {
desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";"; desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";

5
src/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java
View File

@ -13,6 +13,8 @@ public class TypeToDescriptor implements TypeVisitor<String>{
@Override @Override
public String visit(RefType refType) { public String visit(RefType refType) {
return refType.getName().toString().replace(".", "/"); return refType.getName().toString().replace(".", "/");
// String t = refType.getName().toString().replace(".", "/");
// return t.equals("Fun1")?(t+"$$"):t;
} }
@Override @Override
@ -27,7 +29,8 @@ public class TypeToDescriptor implements TypeVisitor<String>{
@Override @Override
public String visit(ExtendsWildcardType extendsWildcardType) { public String visit(ExtendsWildcardType extendsWildcardType) {
throw new NotImplementedException(); return extendsWildcardType.getInnerType().toString();
//throw new NotImplementedException();
} }
@Override @Override

51
src/de/dhbwstuttgart/bytecode/signature/Signature.java
View File

@ -59,7 +59,7 @@ public class Signature {
private void createSignatureForFunN(LambdaExpression lambdaExpression, int numberOfParams) { private void createSignatureForFunN(LambdaExpression lambdaExpression, int numberOfParams) {
sw.visitClassBound().visitEnd(); // sw.visitClassBound().visitEnd();
for(int i = 0;i<numberOfParams;i++) { for(int i = 0;i<numberOfParams;i++) {
int j = i+1; int j = i+1;
sw.visitFormalTypeParameter("T"+ j); sw.visitFormalTypeParameter("T"+ j);
@ -92,7 +92,31 @@ public class Signature {
GenericTypeVar g = itr.next(); GenericTypeVar g = itr.next();
getBoundsOfTypeVar(g,genericsAndBoundsMethod); getBoundsOfTypeVar(g,genericsAndBoundsMethod);
} }
// visits each method-parameter to create the 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(ret.substring(0,4).equals("TPH ")) {
String g = ret.substring(4)+"$";
sw.visitFormalTypeParameter(g);
sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
genericsAndBoundsMethod.put(g, Type.getInternalName(Object.class));
sw.visitClassBound().visitEnd();
}
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 ") && !genericsAndBoundsMethod.containsKey(pT)) {
String gP = pT.substring(4)+"$";
sw.visitFormalTypeParameter(gP);
sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
genericsAndBoundsMethod.put(gP, Type.getInternalName(Object.class));
sw.visitClassBound().visitEnd();
}
}
// visit each method-parameter to create the signature
for(String paramName : methodParamsAndTypes.keySet()) { for(String paramName : methodParamsAndTypes.keySet()) {
RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName); RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
// parameter type deswegen ist true // parameter type deswegen ist true
@ -101,6 +125,15 @@ public class Signature {
if(isConstructor) { if(isConstructor) {
sw.visitReturnType().visitBaseType('V'); sw.visitReturnType().visitBaseType('V');
}else { }else {
// String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
// if(ret.substring(0,4).equals("TPH ")) {
// String g = ret.substring(4);
// if(!genericsAndBoundsMethod.containsKey(g)) {
// genericsAndBoundsMethod.put(g, Type.getInternalName(Object.class));
// } else {
// genericsAndBoundsMethod.put(g+"_", Type.getInternalName(Object.class));
// }
// }
RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType(); RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
// return type deswegen ist false // return type deswegen ist false
doVisitParamsOrReturn(returnType, false); doVisitParamsOrReturn(returnType, false);
@ -132,10 +165,16 @@ public class Signature {
break; break;
case "TPH": case "TPH":
RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType; RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) // der Fall wenn die Type eine Interface ist, muss betrachtet werden
sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature())); // Deswegen muss in ResutSet noch enthalten werden, ob die Type eine
// sv.visitClassType(r.acceptTV(new TypeToSignature())); // Interface oder eine Klasse ist.
System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature())); if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
// sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
sv.visitClassType(r.acceptTV(new TypeToSignature()));
} else {
System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
}
break; break;
default: default:
if(!isParameterType) if(!isParameterType)

2
src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java
View File

@ -27,6 +27,8 @@ public class TypeToSignature implements TypeVisitor<String> {
} }
params += ";>"; params += ";>";
} }
// String t = refType.getName().toString().replace(".", "/");
// return t.equals("Fun1")?t+"$$"+params+";":t+params+";";
return refType.getName().toString().replace(".", "/") + params+";"; return refType.getName().toString().replace(".", "/") + params+";";
} }

40
test/bytecode/BinaryTest.java Normal file
View File

@ -0,0 +1,40 @@
package bytecode;
import static org.junit.Assert.*;
import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import org.junit.BeforeClass;
import org.junit.Test;
import de.dhbwstuttgart.core.JavaTXCompiler;
public class BinaryTest {
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/BinaryInMeth.jav";
fileToTest = new File(path);
compiler = new JavaTXCompiler(fileToTest);
compiler.generateBytecode();
pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
classToTest = loader.loadClass("BinaryInMeth");
instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
}
@Test
public void test() {
fail("Not yet implemented");
}
}

44
test/bytecode/FacTest.java Normal file
View File

@ -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 FacTest {
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/Fac.jav";
fileToTest = new File(path);
compiler = new JavaTXCompiler(fileToTest);
compiler.generateBytecode();
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.class);
Integer result = (Integer) getFac.invoke(instanceOfClass,3);
assertEquals(result, 6);
}
}

2
test/bytecode/PlusTest.java
View File

@ -29,7 +29,7 @@ public class PlusTest {
compiler = new JavaTXCompiler(fileToTest); compiler = new JavaTXCompiler(fileToTest);
compiler.generateBytecode(); compiler.generateBytecode();
pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/examples/"; pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)}); loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
classToTest = loader.loadClass("Plus"); classToTest = loader.loadClass("Plus");
instanceOfClass = classToTest.getDeclaredConstructor().newInstance(); instanceOfClass = classToTest.getDeclaredConstructor().newInstance();

44
test/bytecode/RelOpsTest.java Normal file
View File

@ -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 RelOpsTest {
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/RelOps.jav";
fileToTest = new File(path);
compiler = new JavaTXCompiler(fileToTest);
compiler.generateBytecode();
pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
classToTest = loader.loadClass("RelOps");
instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
}
@Test
public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Method m = classToTest.getDeclaredMethod("m", Integer.class,Integer.class);
Boolean result = (Boolean) m.invoke(instanceOfClass, 7,3);
assertFalse(result);
}
}

11
test/bytecode/javFiles/BinaryInMeth.jav Normal file
View File

@ -0,0 +1,11 @@
import java.lang.Integer;
public class BinaryInMeth {
m(a){
return ++a;
}
m2(a,b){
return m(a+b);
}
}

16
test/bytecode/javFiles/Fac.jav Normal file
View File

@ -0,0 +1,16 @@
import java.lang.Integer;
import java.lang.Long;
import java.lang.Double;
public class Fac {
getFac(n){
var res = 1;
var i = 1;
while(i<=n) {
res = res * i;
i++;
}
return res;
}
}

2
test/bytecode/javFiles/Gen.jav
View File

@ -2,7 +2,7 @@ import java.lang.Integer;
import java.util.Vector; import java.util.Vector;
public class Gen{ public class Gen{
Vector<? extends Integer> m(Vector<Integer> v){ Vector<Integer> m(Vector<Integer> v){
return v; return v;
} }
} }

26
test/bytecode/javFiles/Matrix.jav
View File

@ -7,19 +7,19 @@ class Matrix extends Vector<Vector<Integer>> {
var ret = new Matrix(); var ret = new Matrix();
var i = 0; var i = 0;
while(i < size()) { while(i < size()) {
var v1 = this.elementAt(i); // 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++; } // j++; }
ret.addElement(v2); // ret.addElement(v2);
i++; i++;
} }
return ret; return ret;

2
test/bytecode/javFiles/Op.jav
View File

@ -9,7 +9,7 @@ import java.lang.Byte;
public class Op { public class Op {
Integer m(Integer a, Integer b) { m(a, b) {
//var c = a+b; //var c = a+b;
return a+b; return a+b;
} }

2
test/bytecode/javFiles/Plus.jav
View File

@ -1,4 +1,4 @@
import java.lang.Integer; //import java.lang.Integer;
public class Plus { public class Plus {

7
test/bytecode/javFiles/RelOps.jav Normal file
View File

@ -0,0 +1,7 @@
import java.lang.Integer;
public class RelOps {
m(a,b){
return a<b;
}
}

4
test/bytecode/javFiles/While.jav
View File

@ -1,4 +1,8 @@
import java.lang.Integer; import java.lang.Integer;
// wenn nur ein Import da steht,wird die Type von
// dem Literal 2 Number berechnet => Deswegen kann
// nicht auf den Stack geladen.
//import java.lang.Long;
public class While { public class While {
m(x) { m(x) {

107
test/logFiles/log Normal file
View File

@ -0,0 +1,107 @@
FC:\{java.lang.Number=Elem: Node(java.lang.Number)
Prec: [java.lang.Object, java.io.Serializable]
Desc: [java.lang.Integer]
, java.lang.Comparable=Elem: Node(java.lang.Comparable)
Prec: []
Desc: [java.lang.Integer]
, java.lang.Comparable<BWE>=Elem: Node(java.lang.Comparable<BWE>)
Prec: [java.lang.Object]
Desc: []
, java.lang.Integer=Elem: Node(java.lang.Integer)
Prec: [java.lang.Number, java.lang.Object, java.lang.Comparable, java.io.Serializable]
Desc: []
, java.lang.Iterable<CWZ>=Elem: Node(java.lang.Iterable<CWZ>)
Prec: [java.lang.Object]
Desc: []
, java.lang.Iterable<CFZ>=Elem: Node(java.lang.Iterable<CFZ>)
Prec: [java.lang.Object]
Desc: []
, java.util.Collection=Elem: Node(java.util.Collection)
Prec: []
Desc: [java.util.AbstractList<BXU>, java.util.Vector<BXU>, java.util.List<BXU>, java.util.AbstractCollection<BXU>]
, java.util.AbstractCollection<BXU>=Elem: Node(java.util.AbstractCollection<BXU>)
Prec: [java.lang.Object, java.util.Collection]
Desc: [java.util.AbstractList<BXU>, java.util.Vector<BXU>]
, java.util.AbstractList<BXU>=Elem: Node(java.util.AbstractList<BXU>)
Prec: [java.lang.Object, java.util.Collection, java.util.AbstractCollection<BXU>, java.util.List]
Desc: [java.util.Vector<BXU>]
, java.lang.Cloneable=Elem: Node(java.lang.Cloneable)
Prec: [java.lang.Object]
Desc: [java.util.Vector<BXU>]
, java.lang.Comparable<BPP>=Elem: Node(java.lang.Comparable<BPP>)
Prec: [java.lang.Object]
Desc: []
, java.lang.Object=Elem: Node(java.lang.Object)
Prec: [java.lang.Object]
Desc: [java.lang.Number, java.lang.Comparable<BWE>, java.lang.Integer, java.lang.Iterable<CWZ>, java.lang.Iterable<CFZ>, java.util.AbstractCollection<BXU>, java.util.AbstractList<BXU>, java.lang.Cloneable, java.lang.Comparable<BPP>, Gen, java.lang.Object, java.util.Vector<BXU>, java.util.Collection<CMJ>, java.util.RandomAccess, java.util.Collection<CDW>, java.util.List<BXU>, java.io.Serializable, java.lang.Iterable<COM>, java.util.Collection<CUW>]
, java.util.Vector<BXU>=Elem: Node(java.util.Vector<BXU>)
Prec: [java.util.AbstractList<BXU>, java.lang.Cloneable, java.lang.Object, java.util.Collection, java.util.RandomAccess, java.io.Serializable, java.util.AbstractCollection<BXU>, java.util.List]
Desc: []
, Gen=Elem: Node(Gen)
Prec: [java.lang.Object]
Desc: []
, java.util.Collection<CMJ>=Elem: Node(java.util.Collection<CMJ>)
Prec: [java.lang.Object, java.lang.Iterable]
Desc: []
, java.util.RandomAccess=Elem: Node(java.util.RandomAccess)
Prec: [java.lang.Object]
Desc: [java.util.Vector<BXU>]
, java.util.List<BXU>=Elem: Node(java.util.List<BXU>)
Prec: [java.lang.Object, java.util.Collection]
Desc: []
, java.util.Collection<CDW>=Elem: Node(java.util.Collection<CDW>)
Prec: [java.lang.Object, java.lang.Iterable]
Desc: []
, java.io.Serializable=Elem: Node(java.io.Serializable)
Prec: [java.lang.Object]
Desc: [java.lang.Number, java.util.Vector<BXU>, java.lang.Integer]
, java.lang.Iterable<COM>=Elem: Node(java.lang.Iterable<COM>)
Prec: [java.lang.Object]
Desc: []
, java.lang.Iterable=Elem: Node(java.lang.Iterable)
Prec: []
Desc: [java.util.Collection<CMJ>, java.util.Collection<CDW>, java.util.Collection<CUW>]
, java.util.Collection<CUW>=Elem: Node(java.util.Collection<CUW>)
Prec: [java.lang.Object, java.lang.Iterable]
Desc: []
, java.util.List=Elem: Node(java.util.List)
Prec: []
Desc: [java.util.AbstractList<BXU>, java.util.Vector<BXU>]
}
class Gen {
java.util.Vector<java.lang.Integer> m(java.util.Vector<java.lang.Integer> v)({
return (v)::java.util.Vector<java.lang.Integer>;
})::TPH K
Gen()({
super(());
})::TPH N
}Unifikation: [(java.util.Vector<java.lang.Integer> <. java.util.Vector<java.lang.Integer>, )]
Unifikation: []
[]
RES: []