1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 package org.codehaus.groovy.ast;
47
48 import java.util.Iterator;
49 import java.util.List;
50
51 import org.codehaus.groovy.ast.expr.ArrayExpression;
52 import org.codehaus.groovy.ast.expr.BinaryExpression;
53 import org.codehaus.groovy.ast.expr.BooleanExpression;
54 import org.codehaus.groovy.ast.expr.CastExpression;
55 import org.codehaus.groovy.ast.expr.ClassExpression;
56 import org.codehaus.groovy.ast.expr.ClosureExpression;
57 import org.codehaus.groovy.ast.expr.ConstantExpression;
58 import org.codehaus.groovy.ast.expr.ConstructorCallExpression;
59 import org.codehaus.groovy.ast.expr.Expression;
60 import org.codehaus.groovy.ast.expr.FieldExpression;
61 import org.codehaus.groovy.ast.expr.GStringExpression;
62 import org.codehaus.groovy.ast.expr.ListExpression;
63 import org.codehaus.groovy.ast.expr.MapEntryExpression;
64 import org.codehaus.groovy.ast.expr.MapExpression;
65 import org.codehaus.groovy.ast.expr.MethodCallExpression;
66 import org.codehaus.groovy.ast.expr.NegationExpression;
67 import org.codehaus.groovy.ast.expr.NotExpression;
68 import org.codehaus.groovy.ast.expr.PostfixExpression;
69 import org.codehaus.groovy.ast.expr.PrefixExpression;
70 import org.codehaus.groovy.ast.expr.PropertyExpression;
71 import org.codehaus.groovy.ast.expr.RangeExpression;
72 import org.codehaus.groovy.ast.expr.RegexExpression;
73 import org.codehaus.groovy.ast.expr.StaticMethodCallExpression;
74 import org.codehaus.groovy.ast.expr.TernaryExpression;
75 import org.codehaus.groovy.ast.expr.TupleExpression;
76 import org.codehaus.groovy.ast.expr.VariableExpression;
77 import org.codehaus.groovy.ast.stmt.AssertStatement;
78 import org.codehaus.groovy.ast.stmt.BlockStatement;
79 import org.codehaus.groovy.ast.stmt.BreakStatement;
80 import org.codehaus.groovy.ast.stmt.CaseStatement;
81 import org.codehaus.groovy.ast.stmt.CatchStatement;
82 import org.codehaus.groovy.ast.stmt.ContinueStatement;
83 import org.codehaus.groovy.ast.stmt.DoWhileStatement;
84 import org.codehaus.groovy.ast.stmt.ExpressionStatement;
85 import org.codehaus.groovy.ast.stmt.ForStatement;
86 import org.codehaus.groovy.ast.stmt.IfStatement;
87 import org.codehaus.groovy.ast.stmt.ReturnStatement;
88 import org.codehaus.groovy.ast.stmt.Statement;
89 import org.codehaus.groovy.ast.stmt.SwitchStatement;
90 import org.codehaus.groovy.ast.stmt.SynchronizedStatement;
91 import org.codehaus.groovy.ast.stmt.ThrowStatement;
92 import org.codehaus.groovy.ast.stmt.TryCatchStatement;
93 import org.codehaus.groovy.ast.stmt.WhileStatement;
94
95 /***
96 * Abstract base class for any GroovyCodeVisitory which by default
97 * just walks the code and expression tree
98 *
99 * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
100 * @version $Revision: 1.10 $
101 */
102 public abstract class CodeVisitorSupport implements GroovyCodeVisitor {
103
104 public void visitBlockStatement(BlockStatement block) {
105 List statements = block.getStatements();
106 for (Iterator iter = statements.iterator(); iter.hasNext(); ) {
107 Statement statement = (Statement) iter.next();
108 statement.visit(this);
109 }
110 }
111
112 public void visitForLoop(ForStatement forLoop) {
113 forLoop.getCollectionExpression().visit(this);
114 forLoop.getLoopBlock().visit(this);
115 }
116
117 public void visitWhileLoop(WhileStatement loop) {
118 loop.getBooleanExpression().visit(this);
119 loop.getLoopBlock().visit(this);
120 }
121
122 public void visitDoWhileLoop(DoWhileStatement loop) {
123 loop.getLoopBlock().visit(this);
124 loop.getBooleanExpression().visit(this);
125 }
126
127 public void visitIfElse(IfStatement ifElse) {
128 ifElse.getBooleanExpression().visit(this);
129 ifElse.getIfBlock().visit(this);
130 ifElse.getElseBlock().visit(this);
131 }
132
133 public void visitExpressionStatement(ExpressionStatement statement) {
134 statement.getExpression().visit(this);
135 }
136
137 public void visitReturnStatement(ReturnStatement statement) {
138 statement.getExpression().visit(this);
139 }
140
141 public void visitAssertStatement(AssertStatement statement) {
142 statement.getBooleanExpression().visit(this);
143 statement.getMessageExpression().visit(this);
144 }
145
146 public void visitTryCatchFinally(TryCatchStatement statement) {
147 statement.getTryStatement().visit(this);
148 List list = statement.getCatchStatements();
149 for (Iterator iter = list.iterator(); iter.hasNext(); ) {
150 CatchStatement catchStatement = (CatchStatement) iter.next();
151 catchStatement.visit(this);
152 }
153 statement.getFinallyStatement().visit(this);
154 }
155
156 public void visitSwitch(SwitchStatement statement) {
157 statement.getExpression().visit(this);
158 List list = statement.getCaseStatements();
159 for (Iterator iter = list.iterator(); iter.hasNext(); ) {
160 CaseStatement caseStatement = (CaseStatement) iter.next();
161 caseStatement.visit(this);
162 }
163 statement.getDefaultStatement().visit(this);
164 }
165
166 public void visitCaseStatement(CaseStatement statement) {
167 statement.getExpression().visit(this);
168 statement.getCode().visit(this);
169 }
170
171 public void visitBreakStatement(BreakStatement statement) {
172 }
173
174 public void visitContinueStatement(ContinueStatement statement) {
175 }
176
177 public void visitSynchronizedStatement(SynchronizedStatement statement) {
178 statement.getExpression().visit(this);
179 statement.getCode().visit(this);
180 }
181
182 public void visitThrowStatement(ThrowStatement statement) {
183 statement.getExpression().visit(this);
184 }
185
186 public void visitMethodCallExpression(MethodCallExpression call) {
187 call.getObjectExpression().visit(this);
188 call.getArguments().visit(this);
189 }
190
191 public void visitStaticMethodCallExpression(StaticMethodCallExpression call) {
192 call.getArguments().visit(this);
193 }
194
195 public void visitConstructorCallExpression(ConstructorCallExpression call) {
196 call.getArguments().visit(this);
197 }
198
199 public void visitBinaryExpression(BinaryExpression expression) {
200 expression.getLeftExpression().visit(this);
201 expression.getRightExpression().visit(this);
202 }
203
204 public void visitTernaryExpression(TernaryExpression expression) {
205 expression.getBooleanExpression().visit(this);
206 expression.getTrueExpression().visit(this);
207 expression.getFalseExpression().visit(this);
208 }
209
210 public void visitPostfixExpression(PostfixExpression expression) {
211 expression.getExpression().visit(this);
212 }
213
214 public void visitPrefixExpression(PrefixExpression expression) {
215 expression.getExpression().visit(this);
216 }
217
218 public void visitBooleanExpression(BooleanExpression expression) {
219 expression.getExpression().visit(this);
220 }
221
222 public void visitNotExpression(NotExpression expression) {
223 expression.getExpression().visit(this);
224 }
225
226 public void visitClosureExpression(ClosureExpression expression) {
227 expression.getCode().visit(this);
228 }
229
230 public void visitTupleExpression(TupleExpression expression) {
231 visitListOfExpressions(expression.getExpressions());
232 }
233
234 public void visitListExpression(ListExpression expression) {
235 visitListOfExpressions(expression.getExpressions());
236 }
237
238 public void visitArrayExpression(ArrayExpression expression) {
239 visitListOfExpressions(expression.getExpressions());
240 }
241
242 public void visitMapExpression(MapExpression expression) {
243 visitListOfExpressions(expression.getMapEntryExpressions());
244
245 }
246
247 public void visitMapEntryExpression(MapEntryExpression expression) {
248 expression.getKeyExpression().visit(this);
249 expression.getValueExpression().visit(this);
250
251 }
252
253 public void visitRangeExpression(RangeExpression expression) {
254 expression.getFrom().visit(this);
255 expression.getTo().visit(this);
256 }
257
258 public void visitNegationExpression(NegationExpression expression) {
259 expression.getExpression().visit(this);
260 }
261
262 public void visitCastExpression(CastExpression expression) {
263 expression.getExpression().visit(this);
264 }
265
266 public void visitConstantExpression(ConstantExpression expression) {
267 }
268
269 public void visitClassExpression(ClassExpression expression) {
270 }
271
272 public void visitVariableExpression(VariableExpression expression) {
273 }
274
275 public void visitPropertyExpression(PropertyExpression expression) {
276 expression.getObjectExpression().visit(this);
277 }
278
279 public void visitFieldExpression(FieldExpression expression) {
280 }
281
282 public void visitRegexExpression(RegexExpression expression) {
283 }
284
285 public void visitGStringExpression(GStringExpression expression) {
286 visitListOfExpressions(expression.getStrings());
287 visitListOfExpressions(expression.getValues());
288 }
289
290 protected void visitListOfExpressions(List list) {
291 for (Iterator iter = list.iterator(); iter.hasNext(); ) {
292 Expression expression = (Expression) iter.next();
293 expression.visit(this);
294 }
295 }
296
297 }