1 package org.apache.bcel.classfile;
2
3 /* ====================================================================
4 * The Apache Software License, Version 1.1
5 *
6 * Copyright (c) 2001 The Apache Software Foundation. All rights
7 * reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 *
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in
18 * the documentation and/or other materials provided with the
19 * distribution.
20 *
21 * 3. The end-user documentation included with the redistribution,
22 * if any, must include the following acknowledgment:
23 * "This product includes software developed by the
24 * Apache Software Foundation (http://www.apache.org/)."
25 * Alternately, this acknowledgment may appear in the software itself,
26 * if and wherever such third-party acknowledgments normally appear.
27 *
28 * 4. The names "Apache" and "Apache Software Foundation" and
29 * "Apache BCEL" must not be used to endorse or promote products
30 * derived from this software without prior written permission. For
31 * written permission, please contact apache@apache.org.
32 *
33 * 5. Products derived from this software may not be called "Apache",
34 * "Apache BCEL", nor may "Apache" appear in their name, without
35 * prior written permission of the Apache Software Foundation.
36 *
37 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
41 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
44 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
45 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
46 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
47 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48 * SUCH DAMAGE.
49 * ====================================================================
50 *
51 * This software consists of voluntary contributions made by many
52 * individuals on behalf of the Apache Software Foundation. For more
53 * information on the Apache Software Foundation, please see
54 * <http://www.apache.org/>.
55 */
56 import java.util.Stack;
57
58 /***
59 * Traverses a JavaClass with another Visitor object 'piggy-backed'
60 * that is applied to all components of a JavaClass object. I.e. this
61 * class supplies the traversal strategy, other classes can make use
62 * of it.
63 *
64 * @version $Id: DescendingVisitor.java,v 1.2 2002/02/04 13:07:30 enver Exp $
65 * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
66 */
67 public class DescendingVisitor implements Visitor {
68 private JavaClass clazz;
69 private Visitor visitor;
70 private Stack stack = new Stack();
71
72 /*** @return container of current entitity, i.e., predecessor during traversal
73 */
74 public Object predecessor() {
75 return predecessor(0);
76 }
77
78 /***
79 * @param level nesting level, i.e., 0 returns the direct predecessor
80 * @return container of current entitity, i.e., predecessor during traversal
81 */
82 public Object predecessor(int level) {
83 int size = stack.size();
84
85 if((size < 2) || (level < 0))
86 return null;
87 else
88 return stack.elementAt(size - (level + 2)); // size - 1 == current
89 }
90
91 /*** @return current object
92 */
93 public Object current() {
94 return stack.peek();
95 }
96
97 /***
98 * @param clazz Class to traverse
99 * @param visitor visitor object to apply to all components
100 */
101 public DescendingVisitor(JavaClass clazz, Visitor visitor) {
102 this.clazz = clazz;
103 this.visitor = visitor;
104 }
105
106 /***
107 * Start traversal.
108 */
109 public void visit() { clazz.accept(this); }
110
111 public void visitJavaClass(JavaClass clazz) {
112 stack.push(clazz);
113 clazz.accept(visitor);
114
115 Field[] fields = clazz.getFields();
116 for(int i=0; i < fields.length; i++)
117 fields[i].accept(this);
118
119 Method[] methods = clazz.getMethods();
120 for(int i=0; i < methods.length; i++)
121 methods[i].accept(this);
122
123 Attribute[] attributes = clazz.getAttributes();
124 for(int i=0; i < attributes.length; i++)
125 attributes[i].accept(this);
126
127 clazz.getConstantPool().accept(this);
128 stack.pop();
129 }
130
131 public void visitField(Field field) {
132 stack.push(field);
133 field.accept(visitor);
134
135 Attribute[] attributes = field.getAttributes();
136 for(int i=0; i < attributes.length; i++)
137 attributes[i].accept(this);
138 stack.pop();
139 }
140
141 public void visitConstantValue(ConstantValue cv) {
142 stack.push(cv);
143 cv.accept(visitor);
144 stack.pop();
145 }
146
147 public void visitMethod(Method method) {
148 stack.push(method);
149 method.accept(visitor);
150
151 Attribute[] attributes = method.getAttributes();
152 for(int i=0; i < attributes.length; i++)
153 attributes[i].accept(this);
154
155 stack.pop();
156 }
157
158 public void visitExceptionTable(ExceptionTable table) {
159 stack.push(table);
160 table.accept(visitor);
161 stack.pop();
162 }
163
164 public void visitCode(Code code) {
165 stack.push(code);
166 code.accept(visitor);
167
168 CodeException[] table = code.getExceptionTable();
169 for(int i=0; i < table.length; i++)
170 table[i].accept(this);
171
172 Attribute[] attributes = code.getAttributes();
173 for(int i=0; i < attributes.length; i++)
174 attributes[i].accept(this);
175 stack.pop();
176 }
177
178 public void visitCodeException(CodeException ce) {
179 stack.push(ce);
180 ce.accept(visitor);
181 stack.pop();
182 }
183
184 public void visitLineNumberTable(LineNumberTable table) {
185 stack.push(table);
186 table.accept(visitor);
187
188 LineNumber[] numbers = table.getLineNumberTable();
189 for(int i=0; i < numbers.length; i++)
190 numbers[i].accept(this);
191 stack.pop();
192 }
193
194 public void visitLineNumber(LineNumber number) {
195 stack.push(number);
196 number.accept(visitor);
197 stack.pop();
198 }
199
200 public void visitLocalVariableTable(LocalVariableTable table) {
201 stack.push(table);
202 table.accept(visitor);
203
204 LocalVariable[] vars = table.getLocalVariableTable();
205 for(int i=0; i < vars.length; i++)
206 vars[i].accept(this);
207 stack.pop();
208 }
209
210 public void visitStackMap(StackMap table) {
211 stack.push(table);
212 table.accept(visitor);
213
214 StackMapEntry[] vars = table.getStackMap();
215
216 for(int i=0; i < vars.length; i++)
217 vars[i].accept(this);
218 stack.pop();
219 }
220
221 public void visitStackMapEntry(StackMapEntry var) {
222 stack.push(var);
223 var.accept(visitor);
224 stack.pop();
225 }
226
227 public void visitLocalVariable(LocalVariable var) {
228 stack.push(var);
229 var.accept(visitor);
230 stack.pop();
231 }
232
233 public void visitConstantPool(ConstantPool cp) {
234 stack.push(cp);
235 cp.accept(visitor);
236
237 Constant[] constants = cp.getConstantPool();
238 for(int i=1; i < constants.length; i++) {
239 if(constants[i] != null)
240 constants[i].accept(this);
241 }
242
243 stack.pop();
244 }
245
246 public void visitConstantClass(ConstantClass constant) {
247 stack.push(constant);
248 constant.accept(visitor);
249 stack.pop();
250 }
251
252 public void visitConstantDouble(ConstantDouble constant) {
253 stack.push(constant);
254 constant.accept(visitor);
255 stack.pop();
256 }
257
258 public void visitConstantFieldref(ConstantFieldref constant) {
259 stack.push(constant);
260 constant.accept(visitor);
261 stack.pop();
262 }
263
264 public void visitConstantFloat(ConstantFloat constant) {
265 stack.push(constant);
266 constant.accept(visitor);
267 stack.pop();
268 }
269
270 public void visitConstantInteger(ConstantInteger constant) {
271 stack.push(constant);
272 constant.accept(visitor);
273 stack.pop();
274 }
275
276 public void visitConstantInterfaceMethodref(ConstantInterfaceMethodref constant) {
277 stack.push(constant);
278 constant.accept(visitor);
279 stack.pop();
280 }
281
282 public void visitConstantLong(ConstantLong constant) {
283 stack.push(constant);
284 constant.accept(visitor);
285 stack.pop();
286 }
287
288 public void visitConstantMethodref(ConstantMethodref constant) {
289 stack.push(constant);
290 constant.accept(visitor);
291 stack.pop();
292 }
293
294 public void visitConstantNameAndType(ConstantNameAndType constant) {
295 stack.push(constant);
296 constant.accept(visitor);
297 stack.pop();
298 }
299
300 public void visitConstantString(ConstantString constant) {
301 stack.push(constant);
302 constant.accept(visitor);
303 stack.pop();
304 }
305
306 public void visitConstantUtf8(ConstantUtf8 constant) {
307 stack.push(constant);
308 constant.accept(visitor);
309 stack.pop();
310 }
311
312 public void visitInnerClasses(InnerClasses ic) {
313 stack.push(ic);
314 ic.accept(visitor);
315
316 InnerClass[] ics = ic.getInnerClasses();
317 for(int i=0; i < ics.length; i++)
318 ics[i].accept(this);
319 stack.pop();
320 }
321
322 public void visitInnerClass(InnerClass inner) {
323 stack.push(inner);
324 inner.accept(visitor);
325 stack.pop();
326 }
327
328 public void visitDeprecated(Deprecated attribute) {
329 stack.push(attribute);
330 attribute.accept(visitor);
331 stack.pop();
332 }
333
334 public void visitSignature(Signature attribute) {
335 stack.push(attribute);
336 attribute.accept(visitor);
337 stack.pop();
338 }
339
340 public void visitSourceFile(SourceFile attribute) {
341 stack.push(attribute);
342 attribute.accept(visitor);
343 stack.pop();
344 }
345
346 public void visitSynthetic(Synthetic attribute) {
347 stack.push(attribute);
348 attribute.accept(visitor);
349 stack.pop();
350 }
351
352 public void visitUnknown(Unknown attribute) {
353 stack.push(attribute);
354 attribute.accept(visitor);
355 stack.pop();
356 }
357 }
This page was automatically generated by Maven