001    /*
002     $Id: CodeVisitorSupport.java,v 1.17 2005/05/11 01:17:38 phk Exp $
003    
004     Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
005    
006     Redistribution and use of this software and associated documentation
007     ("Software"), with or without modification, are permitted provided
008     that the following conditions are met:
009    
010     1. Redistributions of source code must retain copyright
011        statements and notices.  Redistributions must also contain a
012        copy of this document.
013    
014     2. Redistributions in binary form must reproduce the
015        above copyright notice, this list of conditions and the
016        following disclaimer in the documentation and/or other
017        materials provided with the distribution.
018    
019     3. The name "groovy" must not be used to endorse or promote
020        products derived from this Software without prior written
021        permission of The Codehaus.  For written permission,
022        please contact info@codehaus.org.
023    
024     4. Products derived from this Software may not be called "groovy"
025        nor may "groovy" appear in their names without prior written
026        permission of The Codehaus. "groovy" is a registered
027        trademark of The Codehaus.
028    
029     5. Due credit should be given to The Codehaus -
030        http://groovy.codehaus.org/
031    
032     THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
033     ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
034     NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
035     FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
036     THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
037     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
038     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
039     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
040     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
041     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
042     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
043     OF THE POSSIBILITY OF SUCH DAMAGE.
044    
045     */
046    package org.codehaus.groovy.ast;
047    
048    import java.util.Iterator;
049    import java.util.List;
050    
051    import org.codehaus.groovy.ast.expr.*;
052    import org.codehaus.groovy.ast.stmt.AssertStatement;
053    import org.codehaus.groovy.ast.stmt.BlockStatement;
054    import org.codehaus.groovy.ast.stmt.BreakStatement;
055    import org.codehaus.groovy.ast.stmt.CaseStatement;
056    import org.codehaus.groovy.ast.stmt.CatchStatement;
057    import org.codehaus.groovy.ast.stmt.ContinueStatement;
058    import org.codehaus.groovy.ast.stmt.DoWhileStatement;
059    import org.codehaus.groovy.ast.stmt.ExpressionStatement;
060    import org.codehaus.groovy.ast.stmt.ForStatement;
061    import org.codehaus.groovy.ast.stmt.IfStatement;
062    import org.codehaus.groovy.ast.stmt.ReturnStatement;
063    import org.codehaus.groovy.ast.stmt.Statement;
064    import org.codehaus.groovy.ast.stmt.SwitchStatement;
065    import org.codehaus.groovy.ast.stmt.SynchronizedStatement;
066    import org.codehaus.groovy.ast.stmt.ThrowStatement;
067    import org.codehaus.groovy.ast.stmt.TryCatchStatement;
068    import org.codehaus.groovy.ast.stmt.WhileStatement;
069    
070    /**
071     * Abstract base class for any GroovyCodeVisitory which by default
072     * just walks the code and expression tree
073     * 
074     * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
075     * @version $Revision: 1.17 $
076     */
077    public abstract class CodeVisitorSupport implements GroovyCodeVisitor {
078    
079        public void visitBlockStatement(BlockStatement block) {
080            List statements = block.getStatements();
081            for (Iterator iter = statements.iterator(); iter.hasNext(); ) {
082                Statement statement = (Statement) iter.next();
083                statement.visit(this);
084            }
085        }
086    
087        public void visitForLoop(ForStatement forLoop) {
088            forLoop.getCollectionExpression().visit(this);
089            forLoop.getLoopBlock().visit(this);
090        }
091    
092        public void visitWhileLoop(WhileStatement loop) {
093            loop.getBooleanExpression().visit(this);
094            loop.getLoopBlock().visit(this);
095        }
096    
097        public void visitDoWhileLoop(DoWhileStatement loop) {
098            loop.getLoopBlock().visit(this);
099            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 visitSpreadExpression(SpreadExpression expression) {
234            expression.getExpression().visit(this);
235        }
236     
237        public void visitSpreadMapExpression(SpreadMapExpression expression) {
238            expression.getExpression().visit(this);
239        }
240    
241        public void visitMethodPointerExpression(MethodPointerExpression expression) {
242            expression.getExpression().visit(this);
243        }
244    
245        public void visitNegationExpression(NegationExpression expression) {
246            expression.getExpression().visit(this);
247        }
248        
249        public void visitBitwiseNegExpression(BitwiseNegExpression expression) {
250            expression.getExpression().visit(this);
251        }
252        
253        public void visitCastExpression(CastExpression expression) {
254            expression.getExpression().visit(this);
255        }
256    
257        public void visitConstantExpression(ConstantExpression expression) {
258        }
259    
260        public void visitClassExpression(ClassExpression expression) {
261        }
262    
263        public void visitVariableExpression(VariableExpression expression) {
264        }
265    
266        public void visitDeclarationExpression(DeclarationExpression expression) {
267            visitBinaryExpression(expression);
268        }
269        
270        public void visitPropertyExpression(PropertyExpression expression) {
271            expression.getObjectExpression().visit(this);
272        }
273    
274        public void visitAttributeExpression(AttributeExpression expression) {
275            expression.getObjectExpression().visit(this);
276        }
277    
278        public void visitFieldExpression(FieldExpression expression) {
279        }
280    
281        public void visitRegexExpression(RegexExpression expression) {
282        }
283    
284        public void visitGStringExpression(GStringExpression expression) {
285            visitListOfExpressions(expression.getStrings());
286            visitListOfExpressions(expression.getValues());
287        }
288    
289        protected void visitListOfExpressions(List list) {
290            Expression expression, expr2, expr3;
291            for (Iterator iter = list.iterator(); iter.hasNext(); ) {
292                expression = (Expression) iter.next();
293                if (expression instanceof SpreadExpression) {
294                    expr2 = ((SpreadExpression) expression).getExpression();
295                    expr2.visit(this);
296                }
297                else {
298                    expression.visit(this);
299                }
300            }
301        }
302    
303        public void visitCatchStatement(CatchStatement statement) {
304            statement.getCode().visit(this);
305        }
306    }