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 }