JavaTX/JavaCompilerCore
2
0
Fork 3
Code Issues 99 Pull Requests Actions Packages Projects Releases Wiki 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: []