EMMA Coverage Report (generated Mon Nov 26 19:18:24 CET 2007)
[all classes][net.sourceforge.retroweaver.runtime.java.lang.reflect]

COVERAGE SUMMARY FOR SOURCE FILE [ReflectionDescriptor.java]

nameclass, %method, %block, %line, %
ReflectionDescriptor.java71%  (5/7)69%  (54/78)65%  (1054/1632)64%  (235.8/369)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ReflectionDescriptor$GenericArrayTypeImpl0%   (0/1)0%   (0/2)0%   (0/9)0%   (0/4)
ReflectionDescriptor$GenericArrayTypeImpl (Type): void 0%   (0/1)0%   (0/6)0%   (0/3)
getGenericComponentType (): Type 0%   (0/1)0%   (0/3)0%   (0/1)
     
class ReflectionDescriptor$WildcardTypeImpl0%   (0/1)0%   (0/3)0%   (0/13)0%   (0/3)
ReflectionDescriptor$WildcardTypeImpl (): void 0%   (0/1)0%   (0/3)0%   (0/1)
getLowerBounds (): Type [] 0%   (0/1)0%   (0/5)0%   (0/1)
getUpperBounds (): Type [] 0%   (0/1)0%   (0/5)0%   (0/1)
     
class ReflectionDescriptor$SigVisitor100% (1/1)56%  (15/27)55%  (444/805)54%  (98.5/181)
ReflectionDescriptor$SigVisitor (StringBuffer): void 0%   (0/1)0%   (0/29)0%   (0/8)
getDeclaration (): String 0%   (0/1)0%   (0/4)0%   (0/1)
getExceptions (): String 0%   (0/1)0%   (0/9)0%   (0/1)
getReturnType (): String 0%   (0/1)0%   (0/9)0%   (0/1)
visitArrayType (): SignatureVisitor 0%   (0/1)0%   (0/10)0%   (0/3)
visitBaseType (char): void 0%   (0/1)0%   (0/58)0%   (0/20)
visitExceptionType (): SignatureVisitor 0%   (0/1)0%   (0/20)0%   (0/4)
visitInnerClassType (String): void 0%   (0/1)0%   (0/54)0%   (0/10)
visitInterfaceBound (): SignatureVisitor 0%   (0/1)0%   (0/15)0%   (0/4)
visitParameterType (): SignatureVisitor 0%   (0/1)0%   (0/23)0%   (0/7)
visitReturnType (): SignatureVisitor 0%   (0/1)0%   (0/30)0%   (0/7)
visitTypeArgument (): void 0%   (0/1)0%   (0/28)0%   (0/6)
endType (): void 100% (1/1)29%  (12/42)33%  (3/9)
visitTypeArgument (char): SignatureVisitor 100% (1/1)63%  (27/43)70%  (7/10)
visitClassType (String): void 100% (1/1)82%  (59/72)90%  (9.8/11)
visitFormalTypeParameter (String): void 100% (1/1)90%  (35/39)88%  (7.9/9)
endParsing (): void 100% (1/1)91%  (74/81)88%  (14/16)
visitInterface (): SignatureVisitor 100% (1/1)92%  (23/25)98%  (5.9/6)
ReflectionDescriptor$SigVisitor (ReflectionDescriptor$ClassTypeImpl, boolean)... 100% (1/1)100% (37/37)100% (10/10)
endFormal (): void 100% (1/1)100% (19/19)100% (4/4)
endFormals (): void 100% (1/1)100% (24/24)100% (6/6)
endGenericSuperclass (): void 100% (1/1)100% (7/7)100% (2/2)
startType (): void 100% (1/1)100% (7/7)100% (2/2)
visitClassBound (): SignatureVisitor 100% (1/1)100% (7/7)100% (3/3)
visitEnd (): void 100% (1/1)100% (81/81)100% (16/16)
visitSuperclass (): SignatureVisitor 100% (1/1)100% (9/9)100% (4/4)
visitTypeVariable (String): void 100% (1/1)100% (23/23)100% (6/6)
     
class ReflectionDescriptor100% (1/1)79%  (23/29)70%  (444/632)68%  (88.3/130)
ReflectionDescriptor (String, InputStream): void 0%   (0/1)0%   (0/20)0%   (0/6)
debugMessage (String): void 0%   (0/1)0%   (0/30)0%   (0/2)
getEnclosingClassName (): String 0%   (0/1)0%   (0/3)0%   (0/1)
main (String []): void 0%   (0/1)0%   (0/65)0%   (0/12)
visitAnnotation (String, boolean): AnnotationVisitor 0%   (0/1)0%   (0/2)0%   (0/1)
visitSource (String, String): void 0%   (0/1)0%   (0/1)0%   (0/1)
parseStream (String, InputStream): void 100% (1/1)38%  (15/40)41%  (4.5/11)
getMethod (Class, String, String): Method 100% (1/1)75%  (41/55)57%  (5.8/10)
getEnclosingConstructor (): Constructor 100% (1/1)83%  (10/12)67%  (2/3)
getReflectionDescriptor (Class): ReflectionDescriptor 100% (1/1)83%  (25/30)86%  (6/7)
getEnclosingClass (): Class 100% (1/1)86%  (19/22)71%  (5/7)
getConstructor (Class, String): Constructor 100% (1/1)88%  (45/51)69%  (6.9/10)
visit (int, int, String, String, String, String []): void 100% (1/1)89%  (17/19)97%  (3.9/4)
parseSignature (String, boolean, String, String []): void 100% (1/1)90%  (88/98)89%  (16.9/19)
<static initializer> 100% (1/1)100% (5/5)100% (1/1)
ReflectionDescriptor (Class): void 100% (1/1)100% (41/41)100% (9/9)
getEnclosingMethod (): Method 100% (1/1)100% (14/14)100% (3/3)
getGenericInterfaces (): Type [] 100% (1/1)100% (3/3)100% (1/1)
getGenericSuperclass (): Type 100% (1/1)100% (3/3)100% (1/1)
getTypeParameters (): TypeVariable [] 100% (1/1)100% (3/3)100% (1/1)
testConstructorAccess (Constructor, int): boolean 100% (1/1)100% (25/25)100% (3/3)
testFieldAccess (Field, int): boolean 100% (1/1)100% (16/16)100% (2/2)
testMethodAccess (Method, int): boolean 100% (1/1)100% (26/26)100% (3/3)
visitAttribute (Attribute): void 100% (1/1)100% (1/1)100% (1/1)
visitEnd (): void 100% (1/1)100% (1/1)100% (1/1)
visitField (int, String, String, String, Object): FieldVisitor 100% (1/1)100% (9/9)100% (2/2)
visitInnerClass (String, String, String, int): void 100% (1/1)100% (11/11)100% (4/4)
visitMethod (int, String, String, String, String []): MethodVisitor 100% (1/1)100% (16/16)100% (2/2)
visitOuterClass (String, String, String): void 100% (1/1)100% (10/10)100% (4/4)
     
class ReflectionDescriptor$ClassTypeImpl100% (1/1)80%  (4/5)92%  (37/40)92%  (11/12)
getTypeParameters (): TypeVariable [] 0%   (0/1)0%   (0/3)0%   (0/1)
ReflectionDescriptor$ClassTypeImpl (String): void 100% (1/1)100% (9/9)100% (4/4)
ReflectionDescriptor$ClassTypeImpl (String, boolean): void 100% (1/1)100% (9/9)100% (4/4)
setTypeParameters (TypeVariable []): void 100% (1/1)100% (4/4)100% (2/2)
toString (): String 100% (1/1)100% (15/15)100% (1/1)
     
class ReflectionDescriptor$ParameterizedTypeImpl100% (1/1)100% (5/5)96%  (103/107)96%  (27/28)
toString (): String 100% (1/1)95%  (82/86)95%  (19/20)
ReflectionDescriptor$ParameterizedTypeImpl (Type, Type [], Type): void 100% (1/1)100% (12/12)100% (5/5)
getActualTypeArguments (): Type [] 100% (1/1)100% (3/3)100% (1/1)
getOwnerType (): Type 100% (1/1)100% (3/3)100% (1/1)
getRawType (): Type 100% (1/1)100% (3/3)100% (1/1)
     
class ReflectionDescriptor$TypeVariableImpl100% (1/1)100% (7/7)100% (26/26)100% (11/11)
ReflectionDescriptor$TypeVariableImpl (String): void 100% (1/1)100% (6/6)100% (3/3)
getBounds (): Type [] 100% (1/1)100% (3/3)100% (1/1)
getGenericDeclaration (): GenericDeclaration 100% (1/1)100% (3/3)100% (1/1)
getName (): String 100% (1/1)100% (3/3)100% (1/1)
setBounds (Type []): void 100% (1/1)100% (4/4)100% (2/2)
setGenericDeclaration (GenericDeclaration): void 100% (1/1)100% (4/4)100% (2/2)
toString (): String 100% (1/1)100% (3/3)100% (1/1)

1package net.sourceforge.retroweaver.runtime.java.lang.reflect;
2 
3import java.io.IOException;
4import java.io.InputStream;
5import java.lang.reflect.Constructor;
6import java.lang.reflect.Field;
7import java.lang.reflect.Method;
8import java.util.HashMap;
9import java.util.HashSet;
10import java.util.LinkedList;
11import java.util.Map;
12import java.util.Set;
13import java.util.Stack;
14 
15import net.sourceforge.retroweaver.runtime.java.lang.TypeNotPresentException;
16import net.sourceforge.retroweaver.runtime.java.lang.annotation.AIB;
17 
18import org.objectweb.asm.AnnotationVisitor;
19import org.objectweb.asm.Attribute;
20import org.objectweb.asm.ClassReader;
21import org.objectweb.asm.ClassVisitor;
22import org.objectweb.asm.FieldVisitor;
23import org.objectweb.asm.MethodVisitor;
24import org.objectweb.asm.Opcodes;
25import org.objectweb.asm.signature.SignatureReader;
26import org.objectweb.asm.signature.SignatureVisitor;
27 
28public class ReflectionDescriptor implements ClassVisitor {
29 
30        private static final boolean DEBUG = false;
31 
32        private static final Map<Class, ReflectionDescriptor> descriptors = new HashMap<Class, ReflectionDescriptor>();
33 
34        public static ReflectionDescriptor getReflectionDescriptor(Class class_) {
35                synchronized (descriptors) {
36                        ReflectionDescriptor d = descriptors.get(class_);
37                        if (d == null) {
38                                d = new ReflectionDescriptor(class_);
39                                descriptors.put(class_, d);
40                                if (DEBUG) d.debugMessage("Adding descriptor");
41                        }
42                        return d;                        
43                }
44        }
45 
46        private final Class class_;
47 
48        private ReflectionDescriptor(Class class_) {
49                this.class_ = class_;
50                String name = class_.getName();
51 
52                String resource = "/" + name.replace('.', '/') + ".class";
53if (DEBUG) System.out.println("Reading class file: " + resource);
54                InputStream classStream = class_.getResourceAsStream(resource);
55                parseStream(name, classStream);
56        }
57 
58        protected ReflectionDescriptor(String name, InputStream classStream) {
59                class_ = null;
60                parseStream(name, classStream);
61        }
62        
63        private void parseStream(String name, InputStream classStream) {
64                try {
65                        ClassReader r = new ClassReader(classStream);
66                        r.accept(this, ClassReader.SKIP_CODE + ClassReader.SKIP_DEBUG
67                                        + ClassReader.SKIP_FRAMES);
68 
69                } catch (IOException e) {
70                        // Shouldn't generally happen
71                        throw new TypeNotPresentException(
72                                        "[Retroweaver] Unable to read reflection data for: " + name, e);
73                } finally {
74                        try {
75                                if (classStream != null) {
76                                        classStream.close();
77                                }
78                        } catch (IOException e) { // NOPMD by xlv
79                        }
80                }
81        }
82 
83        private String internalName;
84 
85        private String enclosingClassName;
86 
87        private String enclosingMethodName;
88 
89        private String enclosingMethodDesc;
90 
91        private HashMap<String, Integer> fieldAccessTable = new HashMap<String, Integer>();
92 
93        private HashMap<String, Integer> methodAccessTable = new HashMap<String, Integer>();
94 
95        public String getEnclosingClassName() {
96                return enclosingClassName;
97        }
98 
99        public void debugMessage(String msg) {
100                System.out.println(msg +
101                                "\n\tclass: " + class_.getName() +
102                                "\n\tenclosingClassName: " + enclosingClassName +
103                                "\n\tenclosingMethodName: " + enclosingMethodName + ' ' + enclosingMethodDesc);
104        }
105 
106        public Class getEnclosingClass() {
107                //debugMessage("getEnclosingClass");
108                if (enclosingClassName == null) {
109                        return null;
110                }
111 
112                try {
113                        //debugMessage("getEnclosingClass");
114                        String name = enclosingClassName.replace('/', '.');
115                        Class c = class_.getClassLoader().loadClass(name);
116                
117                        return c;
118                } catch (ClassNotFoundException e) {
119                        return null;
120                }
121        }
122 
123        public Method getEnclosingMethod() {
124                //debugMessage("getEnclosingMethod");
125                if (enclosingMethodName == null) {
126                        return null;
127                }
128 
129                return getMethod(getEnclosingClass(), enclosingMethodName, enclosingMethodDesc);
130        }
131 
132        public Constructor getEnclosingConstructor() {
133                //debugMessage("getEnclosingMethod");
134                if (enclosingMethodName == null) {
135                        return null;
136                }
137 
138                return getConstructor(getEnclosingClass(), enclosingMethodDesc);
139        }
140 
141        public boolean testFieldAccess(Field f, int mask) {
142                String name = f.getName();
143                return (fieldAccessTable.get(name).intValue() & mask) != 0;
144        }
145 
146        public boolean testMethodAccess(Method m, int mask) {
147                String name = m.getName();
148                String desc = org.objectweb.asm.Type.getMethodDescriptor(m);
149                return (methodAccessTable.get(name+desc).intValue() & mask) != 0;
150        }
151 
152        public boolean testConstructorAccess(Constructor c, int mask) {
153                String name = "<init>";
154                String desc = org.objectweb.asm.Type.getConstructorDescriptor(c);
155                return (methodAccessTable.get(name+desc).intValue() & mask) != 0;
156        }
157 
158        private Method getMethod(Class class_, String name, String desc) {
159                org.objectweb.asm.Type[] types = org.objectweb.asm.Type.getArgumentTypes(desc);
160 
161        outer_loop:
162                for (Method m : class_.getDeclaredMethods()) {
163                        final org.objectweb.asm.Type[] methodTypes = org.objectweb.asm.Type.getArgumentTypes(m);
164                        if (!m.getName().equals(name)
165                                        || methodTypes.length != types.length) {
166                                continue;
167                        }
168                        for (int i = 0; i < types.length; ++i) {
169                                if (!types[i].equals(methodTypes[i])) {
170                                        continue outer_loop;
171                                }
172                        }
173                        return m;
174                }
175                return null;
176        }
177 
178        private Constructor getConstructor(Class class_, String desc) {
179                org.objectweb.asm.Type[] types = org.objectweb.asm.Type.getArgumentTypes(desc);
180 
181        outer_loop:
182                for (Constructor c : class_.getDeclaredConstructors()) {
183                        final Class[] constructorTypes = c.getParameterTypes();
184                        if (constructorTypes.length != types.length) {
185                                continue;
186                        }
187                        for (int i = 0; i < types.length; ++i) {
188                                if (!types[i].equals(org.objectweb.asm.Type.getType(constructorTypes[i]))) {
189                                        continue outer_loop;
190                                }
191                        }
192                        return c;
193                }
194                return null;
195        }
196 
197        private void parseSignature(String signature, boolean isInterface, String superName, String[] interfaces) {
198                if (signature == null) {
199                        typeParameters = new TypeVariable[0];
200                        genericSuperclass = superName==null?null:new ClassTypeImpl(superName.replaceAll("/", "."));
201                        if (interfaces == null) {
202                                genericInterfaces = new Type[0];
203                        } else {
204                                genericInterfaces = new Type[interfaces.length];
205                                for(int i = 0; i < interfaces.length; i++) {
206                                        genericInterfaces[i] = new ClassTypeImpl(interfaces[i].replaceAll("/", "."), true);
207                                }
208                        }
209                } else {
210                        if (DEBUG) System.out.println("Parsing " + signature);
211                        SignatureReader r = new SignatureReader(signature);
212                        ClassTypeImpl currentType = new ClassTypeImpl(internalName.replaceAll("/", "."), isInterface);
213                        SigVisitor v = new SigVisitor(currentType, false);
214                        r.accept(v);
215                        v.endParsing();
216                        
217                        typeParameters = v.typeParameters;
218                        genericSuperclass = v.genericSuperclass;
219                        genericInterfaces = v.genericInterfaces;
220                }
221                if (isInterface) {
222                        genericSuperclass = null;
223                }
224 
225        }
226 
227        private TypeVariable[] typeParameters;
228 
229        private Type genericSuperclass;
230 
231        private Type[] genericInterfaces;
232 
233        public TypeVariable[] getTypeParameters() throws GenericSignatureFormatError {
234                return typeParameters;
235        }
236 
237        public Type getGenericSuperclass() throws GenericSignatureFormatError, TypeNotPresentException, MalformedParameterizedTypeException {
238                return genericSuperclass;
239        }
240 
241        public Type[] getGenericInterfaces() throws GenericSignatureFormatError, TypeNotPresentException, MalformedParameterizedTypeException {
242                return genericInterfaces;
243        }
244 
245    /**
246     * Visits the header of the class.
247     * 
248     * @param version the class version.
249     * @param access the class's access flags (see {@link Opcodes}). This
250     *        parameter also indicates if the class is deprecated.
251     * @param name the internal name of the class (see
252     *        {@link Type#getInternalName() getInternalName}).
253     * @param signature the signature of this class. May be <tt>null</tt> if
254     *        the class is not a generic one, and does not extend or implement
255     *        generic classes or interfaces.
256     * @param superName the internal of name of the super class (see
257     *        {@link Type#getInternalName() getInternalName}). For interfaces,
258     *        the super class is {@link Object}. May be <tt>null</tt>, but
259     *        only for the {@link Object} class.
260     * @param interfaces the internal names of the class's interfaces (see
261     *        {@link Type#getInternalName() getInternalName}). May be
262     *        <tt>null</tt>.
263     */
264    public void visit(
265            int version,
266            int access,
267            String name,
268            String signature,
269            String superName,
270            String[] interfaces) {
271            internalName = name;
272            boolean isInterface = ( access & Opcodes.ACC_INTERFACE ) == Opcodes.ACC_INTERFACE;
273            parseSignature(signature, isInterface, superName, interfaces);
274    }
275 
276    public void visitSource(String source, String debug) {}
277 
278    /**
279     * Visits the enclosing class of the class. This method must be called only
280     * if the class has an enclosing class.
281     * 
282     * @param owner internal name of the enclosing class of the class.
283     * @param name the name of the method that contains the class, or
284     *        <tt>null</tt> if the class is not enclosed in a method of its
285     *        enclosing class.
286     * @param desc the descriptor of the method that contains the class, or
287     *        <tt>null</tt> if the class is not enclosed in a method of its
288     *        enclosing class.
289     */
290    public void visitOuterClass(String owner, String name, String desc) {
291            enclosingClassName = owner;
292            enclosingMethodName = name;
293            enclosingMethodDesc = desc;
294            //debugMessage("visitOuterClass");
295    }
296 
297    /**
298     * Visits information about an inner class. This inner class is not
299     * necessarily a member of the class being visited.
300     * 
301     * @param name the internal name of an inner class (see
302     *        {@link Type#getInternalName() getInternalName}).
303     * @param outerName the internal name of the class to which the inner class
304     *        belongs (see {@link Type#getInternalName() getInternalName}). May
305     *        be <tt>null</tt>.
306     * @param innerName the (simple) name of the inner class inside its
307     *        enclosing class. May be <tt>null</tt> for anonymous inner
308     *        classes.
309     * @param access the access flags of the inner class as originally declared
310     *        in the enclosing class.
311     */
312    public void visitInnerClass(
313            String name,
314            String outerName,
315            String innerName,
316            int access) {
317            if (name.equals(internalName)) {
318                    if (outerName != null) {
319                            enclosingClassName = outerName;
320                    }
321            }
322            //debugMessage("visitInnerClass");
323    }
324 
325    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
326            return AIB.EMPTY_VISITOR;
327    }
328 
329    public void visitAttribute(Attribute attr) {}
330 
331    public FieldVisitor visitField(
332            int access,
333            String name,
334            String desc,
335            String signature,
336            Object value) {
337            fieldAccessTable.put(name, access);
338            return null;
339    }
340 
341    public MethodVisitor visitMethod(
342            int access,
343            String name,
344            String desc,
345            String signature,
346            String[] exceptions) {
347            methodAccessTable.put(name+desc, access);
348            return null;
349    }
350 
351    public void visitEnd() {}
352 
353    public static void main(String args[]) {
354            String signature = "<E:Ljava/lang/String;>Ljava/util/LinkedList<TE;>;Ljava/io/Serializable;Ljava/lang/Comparable<TE;>;";
355            String internalName = "blah.TopLevel";
356 
357            System.out.println("Parsing " + signature);
358                SignatureReader r = new SignatureReader(signature);
359                ClassTypeImpl currentType = new ClassTypeImpl(internalName.replaceAll("/", "."), false);
360                SigVisitor v = new SigVisitor(currentType, false);
361                r.accept(v);
362                v.endParsing();
363                
364                System.out.println(v.genericInterfaces.length);
365                for(Type t: v.genericInterfaces) {
366                        System.out.println(t);
367                }
368    }
369 
370    private static class SigVisitor implements SignatureVisitor {
371                protected TypeVariable[] typeParameters;
372                protected Type genericSuperclass;
373                protected Type[] genericInterfaces;
374        
375                private Stack<Type> stack = new Stack<Type>();
376 
377                private Set<TypeVariableImpl> typeVariables = new HashSet<TypeVariableImpl>();
378 
379                private LinkedList<TypeVariableImpl> formalTypeParameters = new LinkedList<TypeVariableImpl>();
380 
381                private StringBuffer declaration;
382 
383            private boolean isInterface;
384 
385            private ClassTypeImpl currentType;
386 
387            private boolean seenFormalParameter;
388 
389            private boolean seenInterfaceBound;
390 
391            private boolean seenParameter;
392 
393            private boolean seenInterface;
394 
395            private StringBuffer returnType;
396 
397            private StringBuffer exceptions;
398 
399            /**
400             * Stack used to keep track of class types that have arguments. Each element
401             * of this stack is a boolean encoded in one bit. The top of the stack is
402             * the lowest order bit. Pushing false = *2, pushing true = *2+1, popping =
403             * /2.
404             */
405            private int argumentStack;
406 
407            private Stack<Integer> argumentStackPosition = new Stack<Integer>();
408 
409            /**
410             * Stack used to keep track of array class types. Each element of this stack
411             * is a boolean encoded in one bit. The top of the stack is the lowest order
412             * bit. Pushing false = *2, pushing true = *2+1, popping = /2.
413             */
414            private int arrayStack;
415 
416            private String separator = "";
417 
418            public SigVisitor(final ClassTypeImpl currentType, final boolean isInterface) {
419                this.isInterface = isInterface;
420                this.declaration = new StringBuffer();
421                this.currentType = currentType;
422            }
423 
424            private SigVisitor(final StringBuffer buf) {
425                this.declaration = buf;
426            }
427 
428            /**
429             * Visits a formal type parameter.
430             * 
431             * @param name the name of the formal parameter.
432             */
433            public void visitFormalTypeParameter(final String name) {
434                    if (seenFormalParameter) {
435                            endFormal();
436                    }
437                    TypeVariableImpl t = new TypeVariableImpl(name);
438                    typeVariables.add(t);
439                    formalTypeParameters.add(t);
440                    if (DEBUG) System.out.println("pushing visitFormalTypeParameter " + t);
441 
442                    declaration.append(seenFormalParameter ? ", " : "<").append(name);
443                seenFormalParameter = true;
444                seenInterfaceBound = false;
445            }
446 
447            /**
448             * Visits the class bound of the last visited formal type parameter.
449             * 
450             * @return a non null visitor to visit the signature of the class bound.
451             */
452            public SignatureVisitor visitClassBound() {
453                separator = " extends ";
454                startType();
455                return this;
456            }
457 
458            /**
459             * Visits an interface bound of the last visited formal type parameter.
460             * 
461             * @return a non null visitor to visit the signature of the interface bound.
462             */
463            public SignatureVisitor visitInterfaceBound() {
464                separator = seenInterfaceBound ? ", " : " extends ";
465                seenInterfaceBound = true;
466                startType();
467                return this;
468            }
469 
470            /**
471             * Visits the type of the super class.
472             * 
473             * @return a non null visitor to visit the signature of the super class
474             *         type.
475             */
476            public SignatureVisitor visitSuperclass() {
477                endFormals();
478                separator = " extends ";
479                startType();
480                return this;
481            }
482 
483            /**
484             * Visits the type of an interface implemented by the class.
485             * 
486             * @return a non null visitor to visit the signature of the interface type.
487             */
488            public SignatureVisitor visitInterface() {
489                    if (!seenInterface) {
490                            endGenericSuperclass();
491                    }
492                separator = seenInterface ? ", " : isInterface
493                        ? " extends "
494                        : " implements ";
495                seenInterface = true;
496                startType();
497                return this;
498            }
499 
500            /**
501             * Visits the type of a method parameter.
502             * 
503             * @return a non null visitor to visit the signature of the parameter type.
504             */
505            public SignatureVisitor visitParameterType() {
506                endFormals();
507                if (!seenParameter) {
508                    seenParameter = true;
509                    declaration.append('(');
510                } else {
511                    declaration.append(", ");
512                }
513                startType();
514                return this;
515            }
516 
517            /**
518             * Visits the return type of the method.
519             * 
520             * @return a non null visitor to visit the signature of the return type.
521             */
522            public SignatureVisitor visitReturnType() {
523                endFormals();
524                if (!seenParameter) {
525                    declaration.append('(');
526                } else {
527                    seenParameter = false;
528                }
529                declaration.append(')');
530                returnType = new StringBuffer();
531                return new SigVisitor(returnType);
532            }
533 
534            /**
535             * Visits the type of a method exception.
536             * 
537             * @return a non null visitor to visit the signature of the exception type.
538             */
539            public SignatureVisitor visitExceptionType() {
540                if (exceptions == null) {
541                    exceptions = new StringBuffer();
542                } else {
543                    exceptions.append(", ");
544                }
545                // startType();
546                return new SigVisitor(exceptions);
547            }
548 
549            /**
550             * Visits a signature corresponding to a primitive type.
551             * 
552             * @param descriptor the descriptor of the primitive type, or 'V' for
553             *        <tt>void</tt>.
554             */
555            public void visitBaseType(final char descriptor) {
556                    if (DEBUG) System.out.println("visitBaseType " + descriptor);
557                switch (descriptor) {
558                    case 'V':
559                        declaration.append("void");
560                        break;
561                    case 'B':
562                        declaration.append("byte");
563                        break;
564                    case 'J':
565                        declaration.append("long");
566                        break;
567                    case 'Z':
568                        declaration.append("boolean");
569                        break;
570                    case 'I':
571                        declaration.append("int");
572                        break;
573                    case 'S':
574                        declaration.append("short");
575                        break;
576                    case 'C':
577                        declaration.append("char");
578                        break;
579                    case 'F':
580                        declaration.append("float");
581                        break;
582                    // case 'D':
583                    default:
584                        declaration.append("double");
585                        break;
586                }
587                endType();
588            }
589 
590            /**
591             * Visits a signature corresponding to a type variable.
592             * 
593             * @param name the name of the type variable.
594             */
595            public void visitTypeVariable(final String name) {
596                    if (DEBUG) System.out.println("visitTypeVariable " + name);
597                    TypeVariableImpl t = new TypeVariableImpl(name);
598                    typeVariables.add(t);
599                    stack.push(t);
600                declaration.append(name);
601                endType();
602            }
603 
604            /**
605             * Visits a signature corresponding to an array type.
606             * 
607             * @return a non null visitor to visit the signature of the array element
608             *         type.
609             */
610            public SignatureVisitor visitArrayType() {
611                startType();
612                arrayStack |= 1;
613                return this;
614            }
615 
616            /**
617             * Starts the visit of a signature corresponding to a class or interface
618             * type.
619             * 
620             * @param name the internal name of the class or interface.
621             */
622            public void visitClassType(final String name) {
623                    ClassTypeImpl t = new ClassTypeImpl(name.replace('/', '.'));
624                    stack.push(t);
625                    if (DEBUG) System.out.println("visitClassType " + name.replace('/', '.'));
626 
627                    if (!"java/lang/Object".equals(name)) {
628                    declaration.append(separator).append(name.replace('/', '.'));
629                } else {
630                    // Map<java.lang.Object,java.util.List>
631                    // or
632                    // abstract public V get(Object key); (seen in Dictionary.class)
633                    // should have Object
634                    // but java.lang.String extends java.lang.Object is unnecessary
635                    boolean needObjectClass = argumentStack % 2 != 0 || seenParameter;
636                    if (needObjectClass) {
637                        declaration.append(separator).append(name.replace('/', '.'));
638                    }
639                }
640                separator = "";
641                argumentStack *= 2;
642                argumentStackPosition.push(stack.size());
643            }
644 
645            /**
646             * Visits an inner class.
647             * 
648             * @param name the local name of the inner class in its enclosing class.
649             */
650            public void visitInnerClassType(final String name) {
651                    if (DEBUG) System.out.println("visitInnerClassType " + name);
652                if (argumentStack % 2 != 0) {
653                    declaration.append('>');
654                }
655                argumentStack /= 2;
656                argumentStackPosition.pop();
657                declaration.append('.');
658                declaration.append(separator).append(name.replace('/', '.'));
659                separator = "";
660                argumentStack *= 2;
661                argumentStackPosition.push(stack.size());
662            }
663 
664            /**
665             * Visits an unbounded type argument of the last visited class or inner
666             * class type.
667             */
668            public void visitTypeArgument() {
669                    if (DEBUG) System.out.println("visitTypeArgument");
670                if (argumentStack % 2 == 0) {
671                    ++argumentStack;
672                    declaration.append('<');
673                } else {
674                    declaration.append(", ");
675                }
676                declaration.append('?');
677            }
678 
679            /**
680             * Visits a type argument of the last visited class or inner class type.
681             * 
682             * @param wildcard '+', '-' or '='.
683             * @return a non null visitor to visit the signature of the type argument.
684             */
685            public SignatureVisitor visitTypeArgument(final char tag) {
686                if (argumentStack % 2 == 0) {
687                    ++argumentStack;
688                    declaration.append('<');
689                } else {
690                    declaration.append(", ");
691                }
692 
693                if (tag == SignatureVisitor.EXTENDS) {
694                    declaration.append("? extends ");
695                } else if (tag == SignatureVisitor.SUPER) {
696                    declaration.append("? super ");
697                }
698 
699                startType();
700                return this;
701            }
702 
703            /**
704             * Ends the visit of a signature corresponding to a class or interface type.
705             */
706            public void visitEnd() {
707                    if (DEBUG) System.out.println("visitEnd");
708                    if (DEBUG) System.out.println("\t" + declaration);
709                if (argumentStack % 2 != 0) {
710                        int stackPos = argumentStackPosition.peek().intValue() - 1;
711 
712                        Type raw = stack.elementAt(stackPos);
713                        Type owner = null; // FIXME
714                        
715                        int l = stack.size() - stackPos - 1;
716                        Type args[] = new Type[l];
717                        for(int i = l-1; i >= 0; i--) {
718                                args[i] = stack.pop();
719                        }
720                        stack.pop();
721                        ParameterizedTypeImpl t = new ParameterizedTypeImpl(owner, args, raw);
722                        stack.push(t);
723                    declaration.append('>');
724                }
725                argumentStack /= 2;
726                argumentStackPosition.pop();
727                endType();
728            }
729 
730            public String getDeclaration() {
731                return declaration.toString();
732            }
733 
734            public String getReturnType() {
735                return returnType == null ? null : returnType.toString();
736            }
737 
738            public String getExceptions() {
739                return exceptions == null ? null : exceptions.toString();
740            }
741 
742            // -----------------------------------------------
743 
744            private void endFormal() {
745                    Type bounds[] = stack.toArray(new Type[stack.size()]);
746                    stack.removeAllElements();
747                    formalTypeParameters.getLast().setBounds(bounds);
748            }
749 
750            private void endGenericSuperclass() {
751                    genericSuperclass = stack.pop();
752            }
753 
754            public void endParsing() {
755                    if (!seenInterface) {
756                            endGenericSuperclass();
757                            genericInterfaces = new Type[0];
758                    } else {
759                            genericInterfaces = stack.toArray(new Type[stack.size()]);
760                            stack.removeAllElements();
761                            for(Type t: genericInterfaces) {
762                                    if (t instanceof ParameterizedTypeImpl) {
763                                            ParameterizedTypeImpl p = (ParameterizedTypeImpl) t;
764                                            t = p.raw;
765                                    }
766                                    if (t instanceof ClassTypeImpl) {
767                                            ClassTypeImpl c = (ClassTypeImpl) t;
768                                            c.isInterface = true;
769                                    }
770                            }
771                    }
772                    currentType.setTypeParameters(typeParameters);
773                    for(TypeVariableImpl t: typeVariables) {
774                            t.setGenericDeclaration(currentType);
775                    }
776            }
777 
778            private void endFormals() {
779                if (seenFormalParameter) {
780                        endFormal();
781                    declaration.append('>');
782                    seenFormalParameter = false;
783                }
784                        typeParameters = formalTypeParameters.toArray(new TypeVariable[formalTypeParameters.size()]);
785            }
786 
787            private void startType() {
788                arrayStack *= 2;
789            }
790 
791            private void endType() {
792                if (arrayStack % 2 != 0) {
793                    while (arrayStack % 2 != 0) {
794                            Type t = stack.pop();
795                            stack.push(new GenericArrayTypeImpl(t));
796                        arrayStack /= 2;
797                        declaration.append("[]");
798                    }
799                } else {
800                    arrayStack /= 2;
801                }
802            }
803        }
804        
805        public static class ClassTypeImpl implements Type, GenericDeclaration {
806                private final String name;
807                private boolean isInterface;
808                private TypeVariable<?>[] typeParameters;
809                public ClassTypeImpl(String name) {
810                        this.name = name;
811                        isInterface = false;
812                }
813                public ClassTypeImpl(String name, boolean isInterface) {
814                        this.name = name;
815                        this.isInterface = isInterface;
816                }
817                public String toString() { return (isInterface?"interface ":"class ") + name; }
818                public TypeVariable<?>[] getTypeParameters() {
819                        return typeParameters;
820                }
821                public void setTypeParameters(TypeVariable<?>[] typeParameters) {
822                        this.typeParameters = typeParameters;
823                }
824        }
825 
826        public static class GenericArrayTypeImpl implements GenericArrayType {
827                public GenericArrayTypeImpl(Type genericComponentType) {
828                        this.genericComponentType = genericComponentType;
829                }
830                private Type genericComponentType;
831                public Type getGenericComponentType() throws TypeNotPresentException, MalformedParameterizedTypeException {
832                        return genericComponentType;
833                }
834        }
835 
836        public static class ParameterizedTypeImpl implements ParameterizedType {
837                public ParameterizedTypeImpl(Type owner, Type args[], Type raw) {
838                        this.owner = owner;
839                        this.args = args;
840                        this.raw = raw;
841                }
842                private Type owner, args[], raw;
843 
844                public Type[] getActualTypeArguments() throws TypeNotPresentException, MalformedParameterizedTypeException {
845                        return args;
846                }
847                public Type getOwnerType() {
848                        return owner;
849                }
850                public Type getRawType() {
851                        return raw;
852                }
853                public String toString() {
854                        StringBuffer sb = new StringBuffer();
855                        String s = raw.toString();
856                        if (s.startsWith("class ")) {
857                                s = s.substring(6);
858                        } else if (s.startsWith("interface ")) {
859                                s = s.substring(10);
860                        }
861                        sb.append(s);
862                        if (args.length != 0) {
863                                sb.append('<');
864                                boolean first = true;
865                                for(Type t: args) {
866                                        if (!first) {
867                                                sb.append(", ");
868                                        }
869                                        first = false;
870                                        s = t.toString();
871                                        if (s.startsWith("class ")) {
872                                                s = s.substring(6);
873                                        }
874                                        sb.append(s);
875                                }
876                                sb.append('>');
877                        }
878                        return sb.toString();
879                }
880        }
881 
882        public static class TypeVariableImpl<D extends GenericDeclaration> implements TypeVariable {
883                private final String name;
884 
885                public TypeVariableImpl(String name) {
886                        this.name = name;
887                }
888 
889                private Type[] bounds;
890                private D genericDeclaration;
891 
892                protected void setBounds(Type[] bounds) {
893                        this.bounds = bounds;
894                }
895                public Type[] getBounds() throws TypeNotPresentException, MalformedParameterizedTypeException {
896                        return bounds;
897                }
898 
899                protected void setGenericDeclaration(D d) {
900                        genericDeclaration = d;
901                }
902                public D getGenericDeclaration() {
903                        return genericDeclaration;
904                }
905 
906                public String getName() {
907                        return name;
908                }
909                
910                public String toString() { return name; }
911        }
912 
913        public static class WildcardTypeImpl implements WildcardType {
914                public Type[] getLowerBounds() throws TypeNotPresentException, MalformedParameterizedTypeException {
915                        throw new UnsupportedOperationException("NotImplemented");
916                }
917 
918                public Type[] getUpperBounds() throws TypeNotPresentException, MalformedParameterizedTypeException {
919                        throw new UnsupportedOperationException("NotImplemented");
920                }
921        }
922 
923}

[all classes][net.sourceforge.retroweaver.runtime.java.lang.reflect]
EMMA 2.0.7906 (unsupported private build) (C) Vladimir Roubtsov