From b3b29c076a913ba2c20e266592546c84117bce3d Mon Sep 17 00:00:00 2001 From: hoenicke Date: Thu, 9 Nov 2006 20:58:34 +0000 Subject: [PATCH] generic class declaration works now, but generics are still not propagated correctly. git-svn-id: https://svn.code.sf.net/p/jode/code/branches/generics@1401 379699f6-c40d-0410-875b-85095c16579e --- jode/.classpath | 16 ++++++++ jode/.project | 17 ++++++++ .../net/sf/jode/decompiler/ClassAnalyzer.java | 40 ++++++++++--------- .../sf/jode/decompiler/MethodAnalyzer.java | 3 +- .../sf/jode/decompiler/TabbedPrintWriter.java | 40 ++++++++++++++++++- .../sf/jode/expr/ConstantArrayOperator.java | 4 +- jode/src/net/sf/jode/type/ClassInfoType.java | 5 --- jode/src/net/sf/jode/type/ClassType.java | 4 ++ 8 files changed, 99 insertions(+), 30 deletions(-) create mode 100644 jode/.classpath create mode 100644 jode/.project diff --git a/jode/.classpath b/jode/.classpath new file mode 100644 index 0000000..fbc5703 --- /dev/null +++ b/jode/.classpath @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/jode/.project b/jode/.project new file mode 100644 index 0000000..459e924 --- /dev/null +++ b/jode/.project @@ -0,0 +1,17 @@ + + + Jode + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/jode/src/net/sf/jode/decompiler/ClassAnalyzer.java b/jode/src/net/sf/jode/decompiler/ClassAnalyzer.java index 82469e7..b80ddb1 100644 --- a/jode/src/net/sf/jode/decompiler/ClassAnalyzer.java +++ b/jode/src/net/sf/jode/decompiler/ClassAnalyzer.java @@ -53,10 +53,11 @@ public class ClassAnalyzer { ImportHandler imports; ClassInfo clazz; + ClassType myType; ClassDeclarer parent; ProgressListener progressListener; String[] generics; - Type[] genericTypes; + GenericParameterType[] genericTypes; /** * The complexity for initi#alizing a class. @@ -105,7 +106,7 @@ public class ClassAnalyzer if (signature.charAt(0) == '<') { String[] genericSignatures = TypeSignature.getGenericSignatures(signature); generics = new String[genericSignatures.length]; - genericTypes = new Type[genericSignatures.length]; + genericTypes = new GenericParameterType[genericSignatures.length]; for (int i = 0; i < generics.length; i++) { int colon = genericSignatures[i].indexOf(':'); String genName; @@ -166,6 +167,7 @@ public class ClassAnalyzer this.parent = parent; this.clazz = clazz; + this.myType = Type.tClass(clazz, genericTypes); this.imports = imports; modifiers = clazz.getModifiers(); @@ -244,6 +246,10 @@ public class ClassAnalyzer return clazz; } + public ClassType getType() { + return myType; + } + public String getName() { return name; @@ -505,6 +511,9 @@ public class ClassAnalyzer { dumpDeclaration(writer, null, 0.0, 0.0); } + + public void dumpGenericDeclaration(GenericParameterType gen) { + } public void dumpDeclaration(TabbedPrintWriter writer, ProgressListener pl, double done, double scale) @@ -544,30 +553,23 @@ public class ClassAnalyzer if (!clazz.isInterface()) writer.print("class "); writer.print(name); - String signature = clazz.getSignature(); - System.err.println("Class Signature: "+signature+ " (class "+name+")"); - ClassInfo superClazz = clazz.getSuperclass(); - if (superClazz != null && - superClazz.getName() != "java.lang.Object") { - writer.breakOp(); - writer.print(" extends " + (writer.getClassString - (superClazz, Scope.CLASSNAME))); - } - ClassInfo[] interfaces = clazz.getInterfaces(); - if (interfaces.length > 0) { - writer.breakOp(); - writer.print(clazz.isInterface() ? " extends " : " implements "); - writer.startOp(writer.EXPL_PAREN, 1); - for (int i=0; i < interfaces.length; i++) { + if (genericTypes != null) { + writer.print("<"); + writer.startOp(TabbedPrintWriter.EXPL_PAREN, 0); + for (int i=0; i< genericTypes.length; i++) { if (i > 0) { writer.print(", "); writer.breakOp(); } - writer.print(writer.getClassString - (interfaces[i], Scope.CLASSNAME)); + writer.print(genericTypes[i].getClassName()); + writer.printExtendsImplements(genericTypes[i]); } writer.endOp(); + writer.print(">"); } + String signature = clazz.getSignature(); + System.err.println("Class Signature: "+signature+ " (class "+name+")"); + writer.printExtendsImplements(Type.tClass(clazz)); writer.println(); writer.openBraceClass(); diff --git a/jode/src/net/sf/jode/decompiler/MethodAnalyzer.java b/jode/src/net/sf/jode/decompiler/MethodAnalyzer.java index f9d0aef..c59e687 100644 --- a/jode/src/net/sf/jode/decompiler/MethodAnalyzer.java +++ b/jode/src/net/sf/jode/decompiler/MethodAnalyzer.java @@ -461,8 +461,7 @@ public class MethodAnalyzer implements Scope, ClassDeclarer { Block[] blocks = bb.getBlocks(); FlowBlock[] flows = new FlowBlock[blocks.length]; - int returnCount; - TransformExceptionHandlers excHandlers; + TransformExceptionHandlers excHandlers; { for (int i=0; i < blocks.length; i++) flows[i] = new FlowBlock(this, i, i > 0 ? flows[i-1]: null); diff --git a/jode/src/net/sf/jode/decompiler/TabbedPrintWriter.java b/jode/src/net/sf/jode/decompiler/TabbedPrintWriter.java index 2be7843..439d6bc 100644 --- a/jode/src/net/sf/jode/decompiler/TabbedPrintWriter.java +++ b/jode/src/net/sf/jode/decompiler/TabbedPrintWriter.java @@ -619,6 +619,29 @@ public class TabbedPrintWriter { print(getTypeString(type)); } + public void printExtendsImplements(ClassType clazz) { + ClassType superClazz = clazz.getSuperClass(); + if (superClazz != null && + superClazz.getClassName() != "java.lang.Object") { + breakOp(); + print(" extends " + getTypeString(superClazz)); + } + ClassType[] interfaces = clazz.getInterfaces(); + if (interfaces.length > 0) { + breakOp(); + print(clazz.isInterface() ? " extends " : " implements "); + startOp(EXPL_PAREN, 1); + for (int i=0; i < interfaces.length; i++) { + if (i > 0) { + print(", "); + breakOp(); + } + print(getTypeString(interfaces[i])); + } + endOp(); + } + } + public void pushScope(Scope scope) { scopes.push(scope); } @@ -708,8 +731,21 @@ public class TabbedPrintWriter { if (type instanceof ArrayType) return getTypeString(((ArrayType) type).getElementType()) + "[]"; else if (type instanceof ClassInfoType) { - ClassInfo clazz = ((ClassInfoType) type).getClassInfo(); - return getClassString(clazz, Scope.CLASSNAME); + ClassInfoType classInfoType = (ClassInfoType) type; + ClassInfo clazz = classInfoType.getClassInfo(); + String clazzName = getClassString(clazz, Scope.CLASSNAME); + Type[] genInstances = classInfoType.getGenericInstances(); + if (genInstances == null) + return clazzName; + StringBuffer sb = new StringBuffer(clazzName); + sb.append("<"); + for (int i = 0; i < genInstances.length; i++) { + if (i > 0) + sb.append(","); + sb.append(getTypeString(genInstances[i])); + } + sb.append(">"); + return sb.toString(); } else if (type instanceof ClassType) { String name = ((ClassType) type).getClassName(); if (imports != null) { diff --git a/jode/src/net/sf/jode/expr/ConstantArrayOperator.java b/jode/src/net/sf/jode/expr/ConstantArrayOperator.java index fce087d..678e4db 100644 --- a/jode/src/net/sf/jode/expr/ConstantArrayOperator.java +++ b/jode/src/net/sf/jode/expr/ConstantArrayOperator.java @@ -33,7 +33,7 @@ public class ConstantArrayOperator extends Operator { ? Type.tSubType(((ArrayType)type).getElementType()) : Type.tError; Object emptyVal; - if (argType == type.tError || argType.isOfType(Type.tUObject)) + if (argType == Type.tError || argType.isOfType(Type.tUObject)) emptyVal = null; else if (argType.isOfType(Type.tBoolUInt)) emptyVal = new Integer(0); @@ -104,7 +104,7 @@ public class ConstantArrayOperator extends Operator { writer.print(" "); } writer.print("{ "); - writer.startOp(writer.EXPL_PAREN, 0); + writer.startOp(TabbedPrintWriter.EXPL_PAREN, 0); for (int i=0; i< subExpressions.length; i++) { if (i>0) { writer.print(", "); diff --git a/jode/src/net/sf/jode/type/ClassInfoType.java b/jode/src/net/sf/jode/type/ClassInfoType.java index c3a261e..97b7c9f 100644 --- a/jode/src/net/sf/jode/type/ClassInfoType.java +++ b/jode/src/net/sf/jode/type/ClassInfoType.java @@ -21,18 +21,13 @@ package net.sf.jode.type; import net.sf.jode.bytecode.ClassInfo; import net.sf.jode.bytecode.TypeSignature; import net.sf.jode.util.SimpleMap; -import net.sf.jode.util.SimpleSet; import net.sf.jode.GlobalOptions; import java.lang.reflect.Modifier; import java.io.IOException; -import java.util.Vector; -import java.util.Stack; -import java.util.Hashtable; ///#def COLLECTIONS java.util import java.util.Map; -import java.util.Set; ///#enddef /** diff --git a/jode/src/net/sf/jode/type/ClassType.java b/jode/src/net/sf/jode/type/ClassType.java index 0959c0c..ba31149 100644 --- a/jode/src/net/sf/jode/type/ClassType.java +++ b/jode/src/net/sf/jode/type/ClassType.java @@ -100,6 +100,10 @@ public abstract class ClassType extends ReferenceType { * @return the interfaces' types. */ public abstract ClassType[] getInterfaces(); + + public Type[] getGenericInstances() { + return genericInstances; + } /** * Returns true, if all types in this type set are a super type of