View Javadoc

1   /*
2    $Id: CodeVisitorSupport.java,v 1.12 2005/02/21 17:11:52 phk Exp $
3   
4    Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
5   
6    Redistribution and use of this software and associated documentation
7    ("Software"), with or without modification, are permitted provided
8    that the following conditions are met:
9   
10   1. Redistributions of source code must retain copyright
11      statements and notices.  Redistributions must also contain a
12      copy of this document.
13  
14   2. Redistributions in binary form must reproduce the
15      above copyright notice, this list of conditions and the
16      following disclaimer in the documentation and/or other
17      materials provided with the distribution.
18  
19   3. The name "groovy" must not be used to endorse or promote
20      products derived from this Software without prior written
21      permission of The Codehaus.  For written permission,
22      please contact info@codehaus.org.
23  
24   4. Products derived from this Software may not be called "groovy"
25      nor may "groovy" appear in their names without prior written
26      permission of The Codehaus. "groovy" is a registered
27      trademark of The Codehaus.
28  
29   5. Due credit should be given to The Codehaus -
30      http://groovy.codehaus.org/
31  
32   THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
33   ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
34   NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
35   FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
36   THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
37   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
39   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
41   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
42   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
43   OF THE POSSIBILITY OF SUCH DAMAGE.
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.*;
52  import org.codehaus.groovy.ast.stmt.AssertStatement;
53  import org.codehaus.groovy.ast.stmt.BlockStatement;
54  import org.codehaus.groovy.ast.stmt.BreakStatement;
55  import org.codehaus.groovy.ast.stmt.CaseStatement;
56  import org.codehaus.groovy.ast.stmt.CatchStatement;
57  import org.codehaus.groovy.ast.stmt.ContinueStatement;
58  import org.codehaus.groovy.ast.stmt.DoWhileStatement;
59  import org.codehaus.groovy.ast.stmt.ExpressionStatement;
60  import org.codehaus.groovy.ast.stmt.ForStatement;
61  import org.codehaus.groovy.ast.stmt.IfStatement;
62  import org.codehaus.groovy.ast.stmt.ReturnStatement;
63  import org.codehaus.groovy.ast.stmt.Statement;
64  import org.codehaus.groovy.ast.stmt.SwitchStatement;
65  import org.codehaus.groovy.ast.stmt.SynchronizedStatement;
66  import org.codehaus.groovy.ast.stmt.ThrowStatement;
67  import org.codehaus.groovy.ast.stmt.TryCatchStatement;
68  import org.codehaus.groovy.ast.stmt.WhileStatement;
69  
70  /***
71   * Abstract base class for any GroovyCodeVisitory which by default
72   * just walks the code and expression tree
73   * 
74   * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
75   * @version $Revision: 1.12 $
76   */
77  public abstract class CodeVisitorSupport implements GroovyCodeVisitor {
78  
79      public void visitBlockStatement(BlockStatement block) {
80          List statements = block.getStatements();
81          for (Iterator iter = statements.iterator(); iter.hasNext(); ) {
82              Statement statement = (Statement) iter.next();
83              statement.visit(this);
84          }
85      }
86  
87      public void visitForLoop(ForStatement forLoop) {
88          forLoop.getCollectionExpression().visit(this);
89          forLoop.getLoopBlock().visit(this);
90      }
91  
92      public void visitWhileLoop(WhileStatement loop) {
93          loop.getBooleanExpression().visit(this);
94          loop.getLoopBlock().visit(this);
95      }
96  
97      public void visitDoWhileLoop(DoWhileStatement loop) {
98          loop.getLoopBlock().visit(this);
99          loop.getBooleanExpression().visit(this);
100     }
101 
102     public void visitIfElse(IfStatement ifElse) {
103         ifElse.getBooleanExpression().visit(this);
104         ifElse.getIfBlock().visit(this);
105         ifElse.getElseBlock().visit(this);
106     }
107 
108     public void visitExpressionStatement(ExpressionStatement statement) {
109         statement.getExpression().visit(this);
110     }
111 
112     public void visitReturnStatement(ReturnStatement statement) {
113         statement.getExpression().visit(this);
114     }
115 
116     public void visitAssertStatement(AssertStatement statement) {
117         statement.getBooleanExpression().visit(this);
118         statement.getMessageExpression().visit(this);
119     }
120 
121     public void visitTryCatchFinally(TryCatchStatement statement) {
122         statement.getTryStatement().visit(this);
123         List list = statement.getCatchStatements();
124         for (Iterator iter = list.iterator(); iter.hasNext(); ) {
125             CatchStatement catchStatement = (CatchStatement) iter.next();
126             catchStatement.visit(this);
127         }
128         statement.getFinallyStatement().visit(this);
129     }
130 
131     public void visitSwitch(SwitchStatement statement) {
132         statement.getExpression().visit(this);
133         List list = statement.getCaseStatements();
134         for (Iterator iter = list.iterator(); iter.hasNext(); ) {
135             CaseStatement caseStatement = (CaseStatement) iter.next();
136             caseStatement.visit(this);
137         }
138         statement.getDefaultStatement().visit(this);
139     }
140 
141     public void visitCaseStatement(CaseStatement statement) {
142         statement.getExpression().visit(this);
143         statement.getCode().visit(this);
144     }
145 
146     public void visitBreakStatement(BreakStatement statement) {
147     }
148 
149     public void visitContinueStatement(ContinueStatement statement) {
150     }
151 
152     public void visitSynchronizedStatement(SynchronizedStatement statement) {
153         statement.getExpression().visit(this);
154         statement.getCode().visit(this);
155     }
156 
157     public void visitThrowStatement(ThrowStatement statement) {
158         statement.getExpression().visit(this);
159     }
160 
161     public void visitMethodCallExpression(MethodCallExpression call) {
162         call.getObjectExpression().visit(this);
163         call.getArguments().visit(this);
164     }
165 
166     public void visitStaticMethodCallExpression(StaticMethodCallExpression call) {
167         call.getArguments().visit(this);
168     }
169 
170     public void visitConstructorCallExpression(ConstructorCallExpression call) {
171         call.getArguments().visit(this);
172     }
173 
174     public void visitBinaryExpression(BinaryExpression expression) {
175         expression.getLeftExpression().visit(this);
176         expression.getRightExpression().visit(this);
177     }
178 
179     public void visitTernaryExpression(TernaryExpression expression) {
180         expression.getBooleanExpression().visit(this);
181         expression.getTrueExpression().visit(this);
182         expression.getFalseExpression().visit(this);
183     }
184 
185     public void visitPostfixExpression(PostfixExpression expression) {
186         expression.getExpression().visit(this);
187     }
188 
189     public void visitPrefixExpression(PrefixExpression expression) {
190         expression.getExpression().visit(this);
191     }
192 
193     public void visitBooleanExpression(BooleanExpression expression) {
194 		expression.getExpression().visit(this);
195 	}
196 
197 	public void visitNotExpression(NotExpression expression) {
198 		expression.getExpression().visit(this);
199 	}
200 
201     public void visitClosureExpression(ClosureExpression expression) {
202         expression.getCode().visit(this);
203     }
204     
205     public void visitTupleExpression(TupleExpression expression) {
206         visitListOfExpressions(expression.getExpressions());
207     }
208 
209     public void visitListExpression(ListExpression expression) {
210         visitListOfExpressions(expression.getExpressions());
211     }
212 
213     public void visitArrayExpression(ArrayExpression expression) {
214         visitListOfExpressions(expression.getExpressions());
215     }
216     
217     public void visitMapExpression(MapExpression expression) {
218         visitListOfExpressions(expression.getMapEntryExpressions());
219         
220     }
221 
222     public void visitMapEntryExpression(MapEntryExpression expression) {
223         expression.getKeyExpression().visit(this);
224         expression.getValueExpression().visit(this);
225         
226     }
227 
228     public void visitRangeExpression(RangeExpression expression) {
229         expression.getFrom().visit(this);
230         expression.getTo().visit(this);
231     }
232 
233     public void visitNegationExpression(NegationExpression expression) {
234         expression.getExpression().visit(this);
235     }
236     
237     public void visitBitwiseNegExpression(BitwiseNegExpression expression) {
238         expression.getExpression().visit(this);
239     }
240     
241     public void visitCastExpression(CastExpression expression) {
242         expression.getExpression().visit(this);
243     }
244 
245     public void visitConstantExpression(ConstantExpression expression) {
246     }
247 
248     public void visitClassExpression(ClassExpression expression) {
249     }
250 
251     public void visitVariableExpression(VariableExpression expression) {
252     }
253 
254     public void visitPropertyExpression(PropertyExpression expression) {
255         expression.getObjectExpression().visit(this);
256     }
257 
258     public void visitAttributeExpression(AttributeExpression expression) {
259         expression.getObjectExpression().visit(this);
260     }
261 
262     public void visitFieldExpression(FieldExpression expression) {
263     }
264 
265     public void visitRegexExpression(RegexExpression expression) {
266     }
267 
268     public void visitGStringExpression(GStringExpression expression) {
269         visitListOfExpressions(expression.getStrings());
270         visitListOfExpressions(expression.getValues());
271     }
272 
273     protected void visitListOfExpressions(List list) {
274         for (Iterator iter = list.iterator(); iter.hasNext(); ) {
275             Expression expression = (Expression) iter.next();
276             expression.visit(this);
277         }
278     }
279 
280 }