ReferencedClassVisitor.java revision db267bc191f906f55eaef21a27110cce2ec57fdf 
1/*
2 * ProGuard -- shrinking, optimization, obfuscation, and preverification
3 *             of Java bytecode.
4 *
5 * Copyright (c) 2002-2009 Eric Lafortune (eric@graphics.cornell.edu)
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21package proguard.classfile.visitor;
22
23import proguard.classfile.*;
24import proguard.classfile.attribute.*;
25import proguard.classfile.attribute.annotation.*;
26import proguard.classfile.attribute.annotation.visitor.*;
27import proguard.classfile.attribute.visitor.*;
28import proguard.classfile.constant.*;
29import proguard.classfile.constant.visitor.ConstantVisitor;
30import proguard.classfile.util.SimplifiedVisitor;
31
32/**
33 * This ClassVisitor, MemberVisitor, ConstantVisitor, AttributeVisitor, etc.
34 * lets a given ClassVisitor visit all the referenced classes of the elements
35 * that it visits. Only downstream elements are considered (in order to avoid
36 * loops and repeated visits).
37 *
38 * @author Eric Lafortune
39 */
40public class ReferencedClassVisitor
41extends      SimplifiedVisitor
42implements   ClassVisitor,
43             MemberVisitor,
44             ConstantVisitor,
45             AttributeVisitor,
46             LocalVariableInfoVisitor,
47             LocalVariableTypeInfoVisitor,
48             AnnotationVisitor,
49             ElementValueVisitor
50{
51    private final ClassVisitor classVisitor;
52
53
54    public ReferencedClassVisitor(ClassVisitor classVisitor)
55    {
56        this.classVisitor = classVisitor;
57    }
58
59
60    // Implementations for ClassVisitor.
61
62    public void visitProgramClass(ProgramClass programClass)
63    {
64        // Visit the constant pool entries.
65        programClass.constantPoolEntriesAccept(this);
66
67        // Visit the fields and methods.
68        programClass.fieldsAccept(this);
69        programClass.methodsAccept(this);
70
71        // Visit the attributes.
72        programClass.attributesAccept(this);
73    }
74
75
76    public void visitLibraryClass(LibraryClass libraryClass)
77    {
78        // Visit the superclass and interfaces.
79        libraryClass.superClassAccept(classVisitor);
80        libraryClass.interfacesAccept(classVisitor);
81
82        // Visit the fields and methods.
83        libraryClass.fieldsAccept(this);
84        libraryClass.methodsAccept(this);
85    }
86
87
88    // Implementations for MemberVisitor.
89
90    public void visitProgramMember(ProgramClass programClass, ProgramMember programMember)
91    {
92        // Let the visitor visit the classes referenced in the descriptor string.
93        programMember.referencedClassesAccept(classVisitor);
94
95        // Visit the attributes.
96        programMember.attributesAccept(programClass, this);
97    }
98
99
100    public void visitLibraryMember(LibraryClass programClass, LibraryMember libraryMember)
101    {
102        // Let the visitor visit the classes referenced in the descriptor string.
103        libraryMember.referencedClassesAccept(classVisitor);
104    }
105
106
107    // Implementations for ConstantVisitor.
108
109    public void visitAnyConstant(Clazz clazz, Constant constant) {}
110
111
112    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
113    {
114        // Let the visitor visit the class referenced in the string constant.
115        stringConstant.referencedClassAccept(classVisitor);
116    }
117
118
119    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
120    {
121        // Let the visitor visit the class referenced in the reference constant.
122        refConstant.referencedClassAccept(classVisitor);
123    }
124
125
126    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
127    {
128        // Let the visitor visit the class referenced in the class constant.
129        classConstant.referencedClassAccept(classVisitor);
130    }
131
132
133    // Implementations for AttributeVisitor.
134
135    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
136
137
138    public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute)
139    {
140        // Let the visitor visit the class of the enclosing method.
141        enclosingMethodAttribute.referencedClassAccept(classVisitor);
142    }
143
144
145    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
146    {
147        // Visit the attributes of the code attribute.
148        codeAttribute.attributesAccept(clazz, method, this);
149    }
150
151
152    public void visitLocalVariableTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTableAttribute localVariableTableAttribute)
153    {
154        // Visit the local variables.
155        localVariableTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
156    }
157
158
159    public void visitLocalVariableTypeTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeTableAttribute localVariableTypeTableAttribute)
160    {
161        // Visit the local variable types.
162        localVariableTypeTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
163    }
164
165
166    public void visitSignatureAttribute(Clazz clazz, SignatureAttribute signatureAttribute)
167    {
168        // Let the visitor visit the classes referenced in the signature string.
169        signatureAttribute.referencedClassesAccept(classVisitor);
170    }
171
172
173    public void visitAnyAnnotationsAttribute(Clazz clazz, AnnotationsAttribute annotationsAttribute)
174    {
175        // Visit the annotations.
176        annotationsAttribute.annotationsAccept(clazz, this);
177    }
178
179
180    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
181    {
182        // Visit the parameter annotations.
183        parameterAnnotationsAttribute.annotationsAccept(clazz, method, this);
184    }
185
186
187    public void visitAnnotationDefaultAttribute(Clazz clazz, Method method, AnnotationDefaultAttribute annotationDefaultAttribute)
188    {
189        // Visit the default element value.
190        annotationDefaultAttribute.defaultValueAccept(clazz, this);
191    }
192
193
194    // Implementations for LocalVariableInfoVisitor.
195
196    public void visitLocalVariableInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableInfo localVariableInfo)
197    {
198        // Let the visitor visit the class referenced in the local variable.
199        localVariableInfo.referencedClassAccept(classVisitor);
200    }
201
202
203    // Implementations for LocalVariableTypeInfoVisitor.
204
205    public void visitLocalVariableTypeInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeInfo localVariableTypeInfo)
206    {
207        // Let the visitor visit the classes referenced in the local variable type.
208        localVariableTypeInfo.referencedClassesAccept(classVisitor);
209    }
210
211
212    // Implementations for AnnotationVisitor.
213
214    public void visitAnnotation(Clazz clazz, Annotation annotation)
215    {
216        // Let the visitor visit the classes referenced in the annotation.
217        annotation.referencedClassesAccept(classVisitor);
218
219        // Visit the element values.
220        annotation.elementValuesAccept(clazz, this);
221    }
222
223
224    // Implementations for ElementValueVisitor.
225
226    public void visitAnyElementValue(Clazz clazz, Annotation annotation, ElementValue elementValue) {}
227
228
229    public void visitEnumConstantElementValue(Clazz clazz, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
230    {
231        // Let the visitor visit the classes referenced in the constant element value.
232        enumConstantElementValue.referencedClassesAccept(classVisitor);
233    }
234
235
236    public void visitClassElementValue(Clazz clazz, Annotation annotation, ClassElementValue classElementValue)
237    {
238        // Let the visitor visit the classes referenced in the class element value.
239        classElementValue.referencedClassesAccept(classVisitor);
240    }
241
242
243    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
244    {
245        // Visit the element values.
246        arrayElementValue.elementValuesAccept(clazz, annotation, this);
247    }
248}
249