1 /***
2 *
3 * Copyright 2005 Jeremy Rayner
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 **/
18 package org.codehaus.groovy.antlr.treewalker;
19
20 import java.util.List;
21 import java.util.ArrayList;
22
23 import org.codehaus.groovy.antlr.GroovySourceAST;
24 import org.codehaus.groovy.antlr.AntlrASTProcessor;
25 import org.codehaus.groovy.antlr.parser.GroovyTokenTypes;
26
27 import antlr.collections.AST;
28
29 /***
30 * Helper Class for Antlr AST traversal and visitation.
31 *
32 * @author <a href="mailto:groovy@ross-rayner.com">Jeremy Rayner</a>
33 * @version $Revision: 4538 $
34 */
35
36 public abstract class TraversalHelper implements AntlrASTProcessor {
37 protected List unvisitedNodes;
38 private Visitor v;
39
40 public TraversalHelper(Visitor visitor) {
41 this.unvisitedNodes = new ArrayList();
42 this.v = visitor;
43 }
44
45 protected void setUp(GroovySourceAST ast) {
46 v.setUp();
47 }
48 protected void tearDown(GroovySourceAST ast) {
49 v.tearDown();
50 }
51
52 protected void push(GroovySourceAST ast) {
53 v.push(ast);
54 }
55 protected GroovySourceAST pop() {
56 return v.pop();
57 }
58
59 protected void visitNode(GroovySourceAST ast, int n) {
60 if (ast != null) {
61 switch (ast.getType()) {
62 case GroovyTokenTypes.ABSTRACT : v.visitAbstract(ast,n); break;
63 case GroovyTokenTypes.ANNOTATION : v.visitAnnotation(ast,n); break;
64 case GroovyTokenTypes.ANNOTATIONS : v.visitAnnotations(ast,n); break;
65 case GroovyTokenTypes.ANNOTATION_ARRAY_INIT : v.visitAnnotationArrayInit(ast,n); break;
66 case GroovyTokenTypes.ANNOTATION_DEF : v.visitAnnotationDef(ast,n); break;
67 case GroovyTokenTypes.ANNOTATION_FIELD_DEF : v.visitAnnotationFieldDef(ast,n); break;
68 case GroovyTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR : v.visitAnnotationMemberValuePair(ast,n); break;
69 case GroovyTokenTypes.ARRAY_DECLARATOR : v.visitArrayDeclarator(ast,n); break;
70 case GroovyTokenTypes.ASSIGN : v.visitAssign(ast,n); break;
71 case GroovyTokenTypes.AT : v.visitAt(ast,n); break;
72 case GroovyTokenTypes.BAND : v.visitBand(ast,n); break;
73 case GroovyTokenTypes.BAND_ASSIGN : v.visitBandAssign(ast,n); break;
74 case GroovyTokenTypes.BIG_SUFFIX : v.visitBigSuffix(ast,n); break;
75 case GroovyTokenTypes.BLOCK : v.visitBlock(ast,n); break;
76 case GroovyTokenTypes.BNOT : v.visitBnot(ast,n); break;
77 case GroovyTokenTypes.BOR : v.visitBor(ast,n); break;
78 case GroovyTokenTypes.BOR_ASSIGN : v.visitBorAssign(ast,n); break;
79 case GroovyTokenTypes.BSR : v.visitBsr(ast,n); break;
80 case GroovyTokenTypes.BSR_ASSIGN : v.visitBsrAssign(ast,n); break;
81 case GroovyTokenTypes.BXOR : v.visitBxor(ast,n); break;
82 case GroovyTokenTypes.BXOR_ASSIGN : v.visitBxorAssign(ast,n); break;
83 case GroovyTokenTypes.CASE_GROUP : v.visitCaseGroup(ast,n); break;
84 case GroovyTokenTypes.CLASS_DEF : v.visitClassDef(ast,n); break;
85 case GroovyTokenTypes.CLOSABLE_BLOCK : v.visitClosedBlock(ast,n); break;
86 case GroovyTokenTypes.CLOSABLE_BLOCK_OP : v.visitClosureOp(ast,n); break;
87 case GroovyTokenTypes.COLON : v.visitColon(ast,n); break;
88 case GroovyTokenTypes.COMMA : v.visitComma(ast,n); break;
89 case GroovyTokenTypes.COMPARE_TO : v.visitCompareTo(ast,n); break;
90 case GroovyTokenTypes.CTOR_CALL : v.visitCtorCall(ast,n); break;
91 case GroovyTokenTypes.CTOR_IDENT : v.visitCtorIdent(ast,n); break;
92 case GroovyTokenTypes.DEC : v.visitDec(ast,n); break;
93 case GroovyTokenTypes.DIGIT : v.visitDigit(ast,n); break;
94 case GroovyTokenTypes.DIV : v.visitDiv(ast,n); break;
95 case GroovyTokenTypes.DIV_ASSIGN : v.visitDivAssign(ast,n); break;
96 case GroovyTokenTypes.DOLLAR : v.visitDollar(ast,n); break;
97 case GroovyTokenTypes.DOT : v.visitDot(ast,n); break;
98 case GroovyTokenTypes.DYNAMIC_MEMBER : v.visitDynamicMember(ast,n); break;
99 case GroovyTokenTypes.ELIST : v.visitElist(ast,n); break;
100 case GroovyTokenTypes.EMPTY_STAT : v.visitEmptyStat(ast,n); break;
101 case GroovyTokenTypes.ENUM_CONSTANT_DEF : v.visitEnumConstantDef(ast,n); break;
102 case GroovyTokenTypes.ENUM_DEF : v.visitEnumDef(ast,n); break;
103 case GroovyTokenTypes.EOF : v.visitEof(ast,n); break;
104 case GroovyTokenTypes.EQUAL : v.visitEqual(ast,n); break;
105 case GroovyTokenTypes.ESC : v.visitEsc(ast,n); break;
106 case GroovyTokenTypes.EXPONENT : v.visitExponent(ast,n); break;
107 case GroovyTokenTypes.EXPR : v.visitExpr(ast,n); break;
108 case GroovyTokenTypes.EXTENDS_CLAUSE : v.visitExtendsClause(ast,n); break;
109 case GroovyTokenTypes.FINAL : v.visitFinal(ast,n); break;
110 case GroovyTokenTypes.FLOAT_SUFFIX : v.visitFloatSuffix(ast,n); break;
111 case GroovyTokenTypes.FOR_CONDITION : v.visitForCondition(ast,n); break;
112 case GroovyTokenTypes.FOR_EACH_CLAUSE : v.visitForEachClause(ast,n); break;
113 case GroovyTokenTypes.FOR_INIT : v.visitForInit(ast,n); break;
114 case GroovyTokenTypes.FOR_IN_ITERABLE : v.visitForInIterable(ast,n); break;
115 case GroovyTokenTypes.FOR_ITERATOR : v.visitForIterator(ast,n); break;
116 case GroovyTokenTypes.GE : v.visitGe(ast,n); break;
117 case GroovyTokenTypes.GT : v.visitGt(ast,n); break;
118 case GroovyTokenTypes.HEX_DIGIT : v.visitHexDigit(ast,n); break;
119 case GroovyTokenTypes.IDENT : v.visitIdent(ast,n); break;
120 case GroovyTokenTypes.IMPLEMENTS_CLAUSE : v.visitImplementsClause(ast,n); break;
121 case GroovyTokenTypes.IMPLICIT_PARAMETERS : v.visitImplicitParameters(ast,n); break;
122 case GroovyTokenTypes.IMPORT : v.visitImport(ast,n); break;
123 case GroovyTokenTypes.INC : v.visitInc(ast,n); break;
124 case GroovyTokenTypes.INDEX_OP : v.visitIndexOp(ast,n); break;
125 case GroovyTokenTypes.INSTANCE_INIT : v.visitInstanceInit(ast,n); break;
126 case GroovyTokenTypes.INTERFACE_DEF : v.visitInterfaceDef(ast,n); break;
127 case GroovyTokenTypes.LABELED_ARG : v.visitLabeledArg(ast,n); break;
128 case GroovyTokenTypes.LABELED_STAT : v.visitLabeledStat(ast,n); break;
129 case GroovyTokenTypes.LAND : v.visitLand(ast,n); break;
130 case GroovyTokenTypes.LBRACK : v.visitLbrack(ast,n); break;
131 case GroovyTokenTypes.LCURLY : v.visitLcurly(ast,n); break;
132 case GroovyTokenTypes.LE : v.visitLe(ast,n); break;
133 case GroovyTokenTypes.LETTER : v.visitLetter(ast,n); break;
134 case GroovyTokenTypes.LIST_CONSTRUCTOR : v.visitListConstructor(ast,n); break;
135 case GroovyTokenTypes.LITERAL_any : v.visitLiteralAny(ast,n); break;
136 case GroovyTokenTypes.LITERAL_as : v.visitLiteralAs(ast,n); break;
137 case GroovyTokenTypes.LITERAL_assert : v.visitLiteralAssert(ast,n); break;
138 case GroovyTokenTypes.LITERAL_boolean : v.visitLiteralBoolean(ast,n); break;
139 case GroovyTokenTypes.LITERAL_break : v.visitLiteralBreak(ast,n); break;
140 case GroovyTokenTypes.LITERAL_byte : v.visitLiteralByte(ast,n); break;
141 case GroovyTokenTypes.LITERAL_case : v.visitLiteralCase(ast,n); break;
142 case GroovyTokenTypes.LITERAL_catch : v.visitLiteralCatch(ast,n); break;
143 case GroovyTokenTypes.LITERAL_char : v.visitLiteralChar(ast,n); break;
144 case GroovyTokenTypes.LITERAL_class : v.visitLiteralClass(ast,n); break;
145 case GroovyTokenTypes.LITERAL_continue : v.visitLiteralContinue(ast,n); break;
146 case GroovyTokenTypes.LITERAL_def : v.visitLiteralDef(ast,n); break;
147 case GroovyTokenTypes.LITERAL_default : v.visitLiteralDefault(ast,n); break;
148 case GroovyTokenTypes.LITERAL_double : v.visitLiteralDouble(ast,n); break;
149 case GroovyTokenTypes.LITERAL_else : v.visitLiteralElse(ast,n); break;
150 case GroovyTokenTypes.LITERAL_enum : v.visitLiteralEnum(ast,n); break;
151 case GroovyTokenTypes.LITERAL_extends : v.visitLiteralExtends(ast,n); break;
152 case GroovyTokenTypes.LITERAL_false : v.visitLiteralFalse(ast,n); break;
153 case GroovyTokenTypes.LITERAL_finally : v.visitLiteralFinally(ast,n); break;
154 case GroovyTokenTypes.LITERAL_float : v.visitLiteralFloat(ast,n); break;
155 case GroovyTokenTypes.LITERAL_for : v.visitLiteralFor(ast,n); break;
156 case GroovyTokenTypes.LITERAL_if : v.visitLiteralIf(ast,n); break;
157 case GroovyTokenTypes.LITERAL_implements : v.visitLiteralImplements(ast,n); break;
158 case GroovyTokenTypes.LITERAL_import : v.visitLiteralImport(ast,n); break;
159 case GroovyTokenTypes.LITERAL_in : v.visitLiteralIn(ast,n); break;
160 case GroovyTokenTypes.LITERAL_instanceof : v.visitLiteralInstanceof(ast,n); break;
161 case GroovyTokenTypes.LITERAL_int : v.visitLiteralInt(ast,n); break;
162 case GroovyTokenTypes.LITERAL_interface : v.visitLiteralInterface(ast,n); break;
163 case GroovyTokenTypes.LITERAL_long : v.visitLiteralLong(ast,n); break;
164 case GroovyTokenTypes.LITERAL_native : v.visitLiteralNative(ast,n); break;
165 case GroovyTokenTypes.LITERAL_new : v.visitLiteralNew(ast,n); break;
166 case GroovyTokenTypes.LITERAL_null : v.visitLiteralNull(ast,n); break;
167 case GroovyTokenTypes.LITERAL_package : v.visitLiteralPackage(ast,n); break;
168 case GroovyTokenTypes.LITERAL_private : v.visitLiteralPrivate(ast,n); break;
169 case GroovyTokenTypes.LITERAL_protected : v.visitLiteralProtected(ast,n); break;
170 case GroovyTokenTypes.LITERAL_public : v.visitLiteralPublic(ast,n); break;
171 case GroovyTokenTypes.LITERAL_return : v.visitLiteralReturn(ast,n); break;
172 case GroovyTokenTypes.LITERAL_short : v.visitLiteralShort(ast,n); break;
173 case GroovyTokenTypes.LITERAL_static : v.visitLiteralStatic(ast,n); break;
174 case GroovyTokenTypes.LITERAL_super : v.visitLiteralSuper(ast,n); break;
175 case GroovyTokenTypes.LITERAL_switch : v.visitLiteralSwitch(ast,n); break;
176 case GroovyTokenTypes.LITERAL_synchronized : v.visitLiteralSynchronized(ast,n); break;
177 case GroovyTokenTypes.LITERAL_this : v.visitLiteralThis(ast,n); break;
178 case GroovyTokenTypes.LITERAL_threadsafe : v.visitLiteralThreadsafe(ast,n); break;
179 case GroovyTokenTypes.LITERAL_throw : v.visitLiteralThrow(ast,n); break;
180 case GroovyTokenTypes.LITERAL_throws : v.visitLiteralThrows(ast,n); break;
181 case GroovyTokenTypes.LITERAL_transient : v.visitLiteralTransient(ast,n); break;
182 case GroovyTokenTypes.LITERAL_true : v.visitLiteralTrue(ast,n); break;
183 case GroovyTokenTypes.LITERAL_try : v.visitLiteralTry(ast,n); break;
184 case GroovyTokenTypes.LITERAL_void : v.visitLiteralVoid(ast,n); break;
185 case GroovyTokenTypes.LITERAL_volatile : v.visitLiteralVolatile(ast,n); break;
186 case GroovyTokenTypes.LITERAL_while : v.visitLiteralWhile(ast,n); break;
187 case GroovyTokenTypes.LITERAL_with : v.visitLiteralWith(ast,n); break;
188 case GroovyTokenTypes.LNOT : v.visitLnot(ast,n); break;
189 case GroovyTokenTypes.LOR : v.visitLor(ast,n); break;
190 case GroovyTokenTypes.LPAREN : v.visitLparen(ast,n); break;
191 case GroovyTokenTypes.LT : v.visitLt(ast,n); break;
192 case GroovyTokenTypes.MAP_CONSTRUCTOR : v.visitMapConstructor(ast,n); break;
193 case GroovyTokenTypes.MEMBER_POINTER : v.visitMemberPointer(ast,n); break;
194 case GroovyTokenTypes.METHOD_CALL : v.visitMethodCall(ast,n); break;
195 case GroovyTokenTypes.METHOD_DEF : v.visitMethodDef(ast,n); break;
196 case GroovyTokenTypes.MINUS : v.visitMinus(ast,n); break;
197 case GroovyTokenTypes.MINUS_ASSIGN : v.visitMinusAssign(ast,n); break;
198 case GroovyTokenTypes.ML_COMMENT : v.visitMlComment(ast,n); break;
199 case GroovyTokenTypes.MOD : v.visitMod(ast,n); break;
200 case GroovyTokenTypes.MODIFIERS : v.visitModifiers(ast,n); break;
201 case GroovyTokenTypes.MOD_ASSIGN : v.visitModAssign(ast,n); break;
202 case GroovyTokenTypes.NLS : v.visitNls(ast,n); break;
203 case GroovyTokenTypes.NOT_EQUAL : v.visitNotEqual(ast,n); break;
204 case GroovyTokenTypes.NULL_TREE_LOOKAHEAD : v.visitNullTreeLookahead(ast,n); break;
205 case GroovyTokenTypes.NUM_BIG_DECIMAL : v.visitNumBigDecimal(ast,n); break;
206 case GroovyTokenTypes.NUM_BIG_INT : v.visitNumBigInt(ast,n); break;
207 case GroovyTokenTypes.NUM_DOUBLE : v.visitNumDouble(ast,n); break;
208 case GroovyTokenTypes.NUM_FLOAT : v.visitNumFloat(ast,n); break;
209 case GroovyTokenTypes.NUM_INT : v.visitNumInt(ast,n); break;
210 case GroovyTokenTypes.NUM_LONG : v.visitNumLong(ast,n); break;
211 case GroovyTokenTypes.OBJBLOCK : v.visitObjblock(ast,n); break;
212 case GroovyTokenTypes.ONE_NL : v.visitOneNl(ast,n); break;
213 case GroovyTokenTypes.OPTIONAL_DOT : v.visitOptionalDot(ast,n); break;
214 case GroovyTokenTypes.PACKAGE_DEF : v.visitPackageDef(ast,n); break;
215 case GroovyTokenTypes.PARAMETERS : v.visitParameters(ast,n); break;
216 case GroovyTokenTypes.PARAMETER_DEF : v.visitParameterDef(ast,n); break;
217 case GroovyTokenTypes.PLUS : v.visitPlus(ast,n); break;
218 case GroovyTokenTypes.PLUS_ASSIGN : v.visitPlusAssign(ast,n); break;
219 case GroovyTokenTypes.POST_DEC : v.visitPostDec(ast,n); break;
220 case GroovyTokenTypes.POST_INC : v.visitPostInc(ast,n); break;
221 case GroovyTokenTypes.QUESTION : v.visitQuestion(ast,n); break;
222 case GroovyTokenTypes.RANGE_EXCLUSIVE : v.visitRangeExclusive(ast,n); break;
223 case GroovyTokenTypes.RANGE_INCLUSIVE : v.visitRangeInclusive(ast,n); break;
224 case GroovyTokenTypes.RBRACK : v.visitRbrack(ast,n); break;
225 case GroovyTokenTypes.RCURLY : v.visitRcurly(ast,n); break;
226 case GroovyTokenTypes.REGEXP_CTOR_END : v.visitRegexpCtorEnd(ast,n); break;
227 case GroovyTokenTypes.REGEXP_LITERAL : v.visitRegexpLiteral(ast,n); break;
228 case GroovyTokenTypes.REGEXP_SYMBOL : v.visitRegexpSymbol(ast,n); break;
229 case GroovyTokenTypes.REGEX_FIND : v.visitRegexFind(ast,n); break;
230 case GroovyTokenTypes.REGEX_MATCH : v.visitRegexMatch(ast,n); break;
231 case GroovyTokenTypes.RPAREN : v.visitRparen(ast,n); break;
232 case GroovyTokenTypes.SCOPE_ESCAPE : v.visitScopeEscape(ast,n); break;
233 case GroovyTokenTypes.SELECT_SLOT : v.visitSelectSlot(ast,n); break;
234 case GroovyTokenTypes.SEMI : v.visitSemi(ast,n); break;
235 case GroovyTokenTypes.SH_COMMENT : v.visitShComment(ast,n); break;
236 case GroovyTokenTypes.SL : v.visitSl(ast,n); break;
237 case GroovyTokenTypes.SLIST : v.visitSlist(ast,n); break;
238 case GroovyTokenTypes.SL_ASSIGN : v.visitSlAssign(ast,n); break;
239 case GroovyTokenTypes.SL_COMMENT : v.visitSlComment(ast,n); break;
240 case GroovyTokenTypes.SPREAD_ARG : v.visitSpreadArg(ast,n); break;
241 case GroovyTokenTypes.SPREAD_DOT : v.visitSpreadDot(ast,n); break;
242 case GroovyTokenTypes.SPREAD_MAP_ARG : v.visitSpreadMapArg(ast,n); break;
243 case GroovyTokenTypes.SR : v.visitSr(ast,n); break;
244 case GroovyTokenTypes.SR_ASSIGN : v.visitSrAssign(ast,n); break;
245 case GroovyTokenTypes.STAR : v.visitStar(ast,n); break;
246 case GroovyTokenTypes.STAR_ASSIGN : v.visitStarAssign(ast,n); break;
247 case GroovyTokenTypes.STAR_STAR : v.visitStarStar(ast,n); break;
248 case GroovyTokenTypes.STAR_STAR_ASSIGN : v.visitStarStarAssign(ast,n); break;
249 case GroovyTokenTypes.STATIC_IMPORT : v.visitStaticImport(ast,n); break;
250 case GroovyTokenTypes.STATIC_INIT : v.visitStaticInit(ast,n); break;
251 case GroovyTokenTypes.STRICTFP : v.visitStrictfp(ast,n); break;
252 case GroovyTokenTypes.STRING_CH : v.visitStringCh(ast,n); break;
253 case GroovyTokenTypes.STRING_CONSTRUCTOR : v.visitStringConstructor(ast,n); break;
254 case GroovyTokenTypes.STRING_CTOR_END : v.visitStringCtorEnd(ast,n); break;
255 case GroovyTokenTypes.STRING_CTOR_MIDDLE : v.visitStringCtorMiddle(ast,n); break;
256 case GroovyTokenTypes.STRING_CTOR_START : v.visitStringCtorStart(ast,n); break;
257 case GroovyTokenTypes.STRING_LITERAL : v.visitStringLiteral(ast,n); break;
258 case GroovyTokenTypes.STRING_NL : v.visitStringNl(ast,n); break;
259 case GroovyTokenTypes.SUPER_CTOR_CALL : v.visitSuperCtorCall(ast,n); break;
260 case GroovyTokenTypes.TRIPLE_DOT : v.visitTripleDot(ast,n); break;
261 case GroovyTokenTypes.TYPE : v.visitType(ast,n); break;
262 case GroovyTokenTypes.TYPECAST : v.visitTypecast(ast,n); break;
263 case GroovyTokenTypes.TYPE_ARGUMENT : v.visitTypeArgument(ast,n); break;
264 case GroovyTokenTypes.TYPE_ARGUMENTS : v.visitTypeArguments(ast,n); break;
265 case GroovyTokenTypes.TYPE_LOWER_BOUNDS : v.visitTypeLowerBounds(ast,n); break;
266 case GroovyTokenTypes.TYPE_PARAMETER : v.visitTypeParameter(ast,n); break;
267 case GroovyTokenTypes.TYPE_PARAMETERS : v.visitTypeParameters(ast,n); break;
268 case GroovyTokenTypes.TYPE_UPPER_BOUNDS : v.visitTypeUpperBounds(ast,n); break;
269 case GroovyTokenTypes.UNARY_MINUS : v.visitUnaryMinus(ast,n); break;
270 case GroovyTokenTypes.UNARY_PLUS : v.visitUnaryPlus(ast,n); break;
271 case GroovyTokenTypes.UNUSED_CONST : v.visitUnusedConst(ast,n); break;
272 case GroovyTokenTypes.UNUSED_DO : v.visitUnusedDo(ast,n); break;
273 case GroovyTokenTypes.UNUSED_GOTO : v.visitUnusedGoto(ast,n); break;
274 case GroovyTokenTypes.VARIABLE_DEF : v.visitVariableDef(ast,n); break;
275 case GroovyTokenTypes.VARIABLE_PARAMETER_DEF : v.visitVariableParameterDef(ast,n); break;
276 case GroovyTokenTypes.VOCAB : v.visitVocab(ast,n); break;
277 case GroovyTokenTypes.WILDCARD_TYPE : v.visitWildcardType(ast,n); break;
278 case GroovyTokenTypes.WS : v.visitWs(ast,n); break;
279
280
281 default : v.visitDefault(ast,n); break;
282 }
283 } else {
284
285 v.visitDefault(null,n);
286 }
287 }
288 protected abstract void accept(GroovySourceAST currentNode);
289
290 protected void accept_v_FirstChildsFirstChild_v_Child2_Child3_v_Child4_v___v_LastChild(GroovySourceAST t) {
291 openingVisit(t);
292 GroovySourceAST expr2 = t.childAt(0);
293 skip(expr2);
294 accept(expr2.childAt(0));
295 closingVisit(t);
296
297 GroovySourceAST sibling = (GroovySourceAST)expr2.getNextSibling();
298 boolean firstSList = true;
299 while (sibling != null) {
300 if (!firstSList) {
301 subsequentVisit(t);
302 }
303 firstSList = false;
304 accept(sibling);
305 sibling = (GroovySourceAST)sibling.getNextSibling();
306 }
307 }
308
309 protected void accept_v_FirstChildsFirstChild_v_RestOfTheChildren(GroovySourceAST t) {
310 openingVisit(t);
311 GroovySourceAST expr = t.childAt(0);
312 skip(expr);
313 accept(expr.childAt(0));
314 closingVisit(t);
315 acceptSiblings(expr);
316 }
317
318 protected void accept_FirstChild_v_SecondChild(GroovySourceAST t) {
319 accept(t.childAt(0));
320 subsequentVisit(t);
321 accept(t.childAt(1));
322 }
323 protected void accept_FirstChild_v_SecondChild_v(GroovySourceAST t) {
324 accept(t.childAt(0));
325 openingVisit(t);
326 accept(t.childAt(1));
327 closingVisit(t);
328 }
329
330 protected void accept_FirstChild_v_SecondChildsChildren_v(GroovySourceAST t) {
331 accept(t.childAt(0));
332
333 openingVisit(t);
334 GroovySourceAST secondChild = t.childAt(1);
335 if (secondChild != null) {
336 acceptChildren(secondChild);
337 }
338 closingVisit(t);
339 }
340
341
342 protected void accept_v_FirstChild_SecondChild_v_ThirdChild_v(GroovySourceAST t) {
343 openingVisit(t);
344 accept(t.childAt(0));
345 accept(t.childAt(1));
346 subsequentVisit(t);
347 accept(t.childAt(2));
348 closingVisit(t);
349 }
350
351 protected void accept_FirstChild_v_SecondChild_v_ThirdChild_v(GroovySourceAST t) {
352 accept(t.childAt(0));
353 openingVisit(t);
354 accept(t.childAt(1));
355 subsequentVisit(t);
356 accept(t.childAt(2));
357 closingVisit(t);
358 }
359
360 protected void accept_FirstSecondAndThirdChild_v_v_ForthChild(GroovySourceAST t) {
361 GroovySourceAST child1 = (GroovySourceAST)t.getFirstChild();
362 if (child1 != null){
363 accept(child1);
364 GroovySourceAST child2 = (GroovySourceAST)child1.getNextSibling();
365 if (child2 != null) {
366 accept(child2);
367 GroovySourceAST child3 = (GroovySourceAST)child2.getNextSibling();
368 if (child3 != null) {
369 accept(child3);
370 openingVisit(t);
371 GroovySourceAST child4 = (GroovySourceAST)child3.getNextSibling();
372 if (child4 != null) {
373 subsequentVisit(t);
374 accept(child4);
375 }
376 }
377 }
378 }
379 }
380
381 protected void accept_v_FirstChild_2ndv_SecondChild_v___LastChild_v(GroovySourceAST t) {
382 openingVisit(t);
383 GroovySourceAST child = (GroovySourceAST)t.getFirstChild();
384 if (child != null){
385 accept(child);
386 GroovySourceAST sibling = (GroovySourceAST)child.getNextSibling();
387 if (sibling != null) {
388 secondVisit(t);
389 accept(sibling);
390 sibling = (GroovySourceAST)sibling.getNextSibling();
391 while (sibling != null) {
392 subsequentVisit(t);
393 accept(sibling);
394 sibling = (GroovySourceAST)sibling.getNextSibling();
395 }
396 }
397 }
398 closingVisit(t);
399 }
400
401 protected void accept_v_FirstChild_v_SecondChild_v___LastChild_v(GroovySourceAST t) {
402 openingVisit(t);
403 GroovySourceAST child = (GroovySourceAST)t.getFirstChild();
404 if (child != null){
405 accept(child);
406 GroovySourceAST sibling = (GroovySourceAST)child.getNextSibling();
407 while (sibling != null) {
408 subsequentVisit(t);
409 accept(sibling);
410 sibling = (GroovySourceAST)sibling.getNextSibling();
411 }
412 }
413 closingVisit(t);
414 }
415
416 protected void accept_v_FirstChild_v(GroovySourceAST t) {
417 openingVisit(t);
418 accept(t.childAt(0));
419 closingVisit(t);
420 }
421
422 protected void accept_v_AllChildren_v_Siblings(GroovySourceAST t) {
423 openingVisit(t);
424 acceptChildren(t);
425 closingVisit(t);
426 acceptSiblings(t);
427 }
428
429 protected void accept_v_AllChildren_v(GroovySourceAST t) {
430 openingVisit(t);
431 acceptChildren(t);
432 closingVisit(t);
433 }
434
435 protected void accept_FirstChild_v_RestOfTheChildren(GroovySourceAST t) {
436 accept(t.childAt(0));
437 openingVisit(t);
438 closingVisit(t);
439 acceptSiblings(t.childAt(0));
440 }
441 protected void accept_FirstChild_v_RestOfTheChildren_v_LastChild(GroovySourceAST t) {
442 int count = 0;
443 accept(t.childAt(0));
444 count++;
445 openingVisit(t);
446 if (t.childAt(0) != null) {
447 GroovySourceAST sibling = (GroovySourceAST)t.childAt(0).getNextSibling();
448 while (sibling != null) {
449 if (count == t.getNumberOfChildren() - 1) {closingVisit(t);}
450 accept(sibling);
451 count++;
452 sibling = (GroovySourceAST)sibling.getNextSibling();
453 }
454 }
455
456
457 }
458 protected void accept_FirstChild_v_RestOfTheChildren_v(GroovySourceAST t) {
459 accept(t.childAt(0));
460 openingVisit(t);
461 acceptSiblings(t.childAt(0));
462 closingVisit(t);
463 }
464 protected void accept_v_FirstChild_v_RestOfTheChildren(GroovySourceAST t) {
465 accept_v_FirstChild_v(t);
466 acceptSiblings(t.childAt(0));
467 }
468
469 protected void accept_v_FirstChild_v_RestOfTheChildren_v(GroovySourceAST t) {
470 openingVisit(t);
471 accept(t.childAt(0));
472 subsequentVisit(t);
473 acceptSiblings(t.childAt(0));
474 closingVisit(t);
475 }
476
477 protected void acceptSiblings(GroovySourceAST t) {
478 if (t != null) {
479 GroovySourceAST sibling = (GroovySourceAST)t.getNextSibling();
480 while (sibling != null) {
481 accept(sibling);
482 sibling = (GroovySourceAST)sibling.getNextSibling();
483 }
484 }
485 }
486
487 protected void acceptChildren(GroovySourceAST t) {
488 if (t != null) {
489 GroovySourceAST child = (GroovySourceAST)t.getFirstChild();
490 if (child != null){
491 accept(child);
492 acceptSiblings(child);
493 }
494 }
495 }
496
497 protected void skip(GroovySourceAST expr) {
498 unvisitedNodes.remove(expr);
499 }
500
501 protected void openingVisit(GroovySourceAST t) {
502 unvisitedNodes.remove(t);
503
504 int n = Visitor.OPENING_VISIT;
505 visitNode(t, n);
506 }
507
508 protected void secondVisit(GroovySourceAST t) {
509 int n = Visitor.SECOND_VISIT;
510 visitNode(t, n);
511 }
512
513 protected void subsequentVisit(GroovySourceAST t) {
514 int n = Visitor.SUBSEQUENT_VISIT;
515 visitNode(t, n);
516 }
517
518 protected void closingVisit(GroovySourceAST t) {
519 int n = Visitor.CLOSING_VISIT;
520 visitNode(t, n);
521 }
522
523 public AST process(AST t) {
524 GroovySourceAST node = (GroovySourceAST) t;
525
526
527 setUp(node);
528 accept(node);
529 acceptSiblings(node);
530 tearDown(node);
531 return null;
532 }
533 }