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