View Javadoc

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