001    /**
002     *
003     * Copyright 2005 Jeremy Rayner
004     *
005     * Licensed under the Apache License, Version 2.0 (the "License");
006     * you may not use this file except in compliance with the License.
007     * You may obtain a copy of the License at
008     *
009     * http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     *
017     **/
018    package org.codehaus.groovy.antlr.treewalker;
019    
020    import java.util.List;
021    import java.util.ArrayList;
022    
023    import org.codehaus.groovy.antlr.GroovySourceAST;
024    import org.codehaus.groovy.antlr.AntlrASTProcessor;
025    import org.codehaus.groovy.antlr.parser.GroovyTokenTypes;
026    
027    import antlr.collections.AST;
028    
029    /**                                                  
030     * Helper Class for Antlr AST traversal and visitation.
031     *
032     * @author <a href="mailto:groovy@ross-rayner.com">Jeremy Rayner</a>
033     * @version $Revision: 4538 $
034     */
035    
036    public abstract class TraversalHelper implements AntlrASTProcessor {
037        protected List unvisitedNodes;
038        private Visitor v;
039    
040        public TraversalHelper(Visitor visitor) {
041            this.unvisitedNodes = new ArrayList();
042            this.v = visitor;
043        }
044    
045        protected void setUp(GroovySourceAST ast) {
046            v.setUp();
047        }
048        protected void tearDown(GroovySourceAST ast) {
049            v.tearDown();
050        }
051    
052        protected void push(GroovySourceAST ast) {
053            v.push(ast);
054        }
055        protected GroovySourceAST pop() {
056            return v.pop();
057        }
058    
059        protected void visitNode(GroovySourceAST ast, int n) {
060            if (ast != null) {
061                switch (ast.getType()) {
062                    case GroovyTokenTypes.ABSTRACT                      :   v.visitAbstract(ast,n);                     break;
063                    case GroovyTokenTypes.ANNOTATION                    :   v.visitAnnotation(ast,n);                   break;
064                    case GroovyTokenTypes.ANNOTATIONS                   :   v.visitAnnotations(ast,n);                  break;
065                    case GroovyTokenTypes.ANNOTATION_ARRAY_INIT         :   v.visitAnnotationArrayInit(ast,n);          break; // obsolete?
066                    case GroovyTokenTypes.ANNOTATION_DEF                :   v.visitAnnotationDef(ast,n);                break;
067                    case GroovyTokenTypes.ANNOTATION_FIELD_DEF          :   v.visitAnnotationFieldDef(ast,n);           break;
068                    case GroovyTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR  :   v.visitAnnotationMemberValuePair(ast,n);    break;
069                    case GroovyTokenTypes.ARRAY_DECLARATOR              :   v.visitArrayDeclarator(ast,n);              break;
070                    case GroovyTokenTypes.ASSIGN                        :   v.visitAssign(ast,n);                       break;
071                    case GroovyTokenTypes.AT                            :   v.visitAt(ast,n);                           break;
072                    case GroovyTokenTypes.BAND                          :   v.visitBand(ast,n);                         break;
073                    case GroovyTokenTypes.BAND_ASSIGN                   :   v.visitBandAssign(ast,n);                   break;
074                    case GroovyTokenTypes.BIG_SUFFIX                    :   v.visitBigSuffix(ast,n);                    break;
075                    case GroovyTokenTypes.BLOCK                         :   v.visitBlock(ast,n);                        break;
076                    case GroovyTokenTypes.BNOT                          :   v.visitBnot(ast,n);                         break;
077                    case GroovyTokenTypes.BOR                           :   v.visitBor(ast,n);                          break;
078                    case GroovyTokenTypes.BOR_ASSIGN                    :   v.visitBorAssign(ast,n);                    break;
079                    case GroovyTokenTypes.BSR                           :   v.visitBsr(ast,n);                          break;
080                    case GroovyTokenTypes.BSR_ASSIGN                    :   v.visitBsrAssign(ast,n);                    break;
081                    case GroovyTokenTypes.BXOR                          :   v.visitBxor(ast,n);                         break;
082                    case GroovyTokenTypes.BXOR_ASSIGN                   :   v.visitBxorAssign(ast,n);                   break;
083                    case GroovyTokenTypes.CASE_GROUP                    :   v.visitCaseGroup(ast,n);                    break;
084                    case GroovyTokenTypes.CLASS_DEF                     :   v.visitClassDef(ast,n);                     break;
085                    case GroovyTokenTypes.CLOSABLE_BLOCK                :   v.visitClosedBlock(ast,n);                  break;
086                    case GroovyTokenTypes.CLOSABLE_BLOCK_OP             :   v.visitClosureOp(ast,n);                    break;
087                    case GroovyTokenTypes.COLON                         :   v.visitColon(ast,n);                        break;
088                    case GroovyTokenTypes.COMMA                         :   v.visitComma(ast,n);                        break;
089                    case GroovyTokenTypes.COMPARE_TO                    :   v.visitCompareTo(ast,n);                    break;
090                    case GroovyTokenTypes.CTOR_CALL                     :   v.visitCtorCall(ast,n);                     break;
091                    case GroovyTokenTypes.CTOR_IDENT                    :   v.visitCtorIdent(ast,n);                    break;
092                    case GroovyTokenTypes.DEC                           :   v.visitDec(ast,n);                          break;
093                    case GroovyTokenTypes.DIGIT                         :   v.visitDigit(ast,n);                        break;
094                    case GroovyTokenTypes.DIV                           :   v.visitDiv(ast,n);                          break;
095                    case GroovyTokenTypes.DIV_ASSIGN                    :   v.visitDivAssign(ast,n);                    break;
096                    case GroovyTokenTypes.DOLLAR                        :   v.visitDollar(ast,n);                       break;
097                    case GroovyTokenTypes.DOT                           :   v.visitDot(ast,n);                          break;
098                    case GroovyTokenTypes.DYNAMIC_MEMBER                :   v.visitDynamicMember(ast,n);                break;
099                    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                // the supplied AST was null
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            // process each node in turn
527            setUp(node);
528            accept(node);
529            acceptSiblings(node);
530            tearDown(node);
531            return null;
532        }    
533    }