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 import org.codehaus.groovy.antlr.GroovySourceAST; 023 import org.codehaus.groovy.antlr.AntlrASTProcessor; 024 import org.codehaus.groovy.antlr.parser.GroovyTokenTypes; 025 026 import antlr.collections.AST; 027 028 /** 029 * Helper Class for Antlr AST traversal and visitation. 030 * 031 * @author <a href="mailto:groovy@ross-rayner.com">Jeremy Rayner</a> 032 * @version $Revision: 1.6 $ 033 */ 034 035 public abstract class TraversalHelper implements AntlrASTProcessor { 036 protected List unvisitedNodes; 037 private Visitor v; 038 039 public TraversalHelper(Visitor visitor) { 040 this.unvisitedNodes = new ArrayList(); 041 this.v = visitor; 042 } 043 044 protected void setUp(GroovySourceAST ast) { 045 v.setUp(); 046 } 047 protected void tearDown(GroovySourceAST ast) { 048 v.tearDown(); 049 } 050 051 protected void visitNode(GroovySourceAST ast, int n) { 052 switch (ast.getType()) { 053 case GroovyTokenTypes.ABSTRACT : v.visitAbstract(ast,n); break; 054 case GroovyTokenTypes.ANNOTATION : v.visitAnnotation(ast,n); break; 055 case GroovyTokenTypes.ANNOTATIONS : v.visitAnnotations(ast,n); break; 056 case GroovyTokenTypes.ANNOTATION_ARRAY_INIT : v.visitAnnotationArrayInit(ast,n); break; 057 case GroovyTokenTypes.ANNOTATION_DEF : v.visitAnnotationDef(ast,n); break; 058 case GroovyTokenTypes.ANNOTATION_FIELD_DEF : v.visitAnnotationFieldDef(ast,n); break; 059 case GroovyTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR : v.visitAnnotationMemberValuePair(ast,n); break; 060 case GroovyTokenTypes.ARRAY_DECLARATOR : v.visitArrayDeclarator(ast,n); break; 061 case GroovyTokenTypes.ASSIGN : v.visitAssign(ast,n); break; 062 case GroovyTokenTypes.AT : v.visitAt(ast,n); break; 063 case GroovyTokenTypes.BAND : v.visitBand(ast,n); break; 064 case GroovyTokenTypes.BAND_ASSIGN : v.visitBandAssign(ast,n); break; 065 case GroovyTokenTypes.BIG_SUFFIX : v.visitBigSuffix(ast,n); break; 066 case GroovyTokenTypes.BLOCK : v.visitBlock(ast,n); break; 067 case GroovyTokenTypes.BNOT : v.visitBnot(ast,n); break; 068 case GroovyTokenTypes.BOR : v.visitBor(ast,n); break; 069 case GroovyTokenTypes.BOR_ASSIGN : v.visitBorAssign(ast,n); break; 070 case GroovyTokenTypes.BSR : v.visitBsr(ast,n); break; 071 case GroovyTokenTypes.BSR_ASSIGN : v.visitBsrAssign(ast,n); break; 072 case GroovyTokenTypes.BXOR : v.visitBxor(ast,n); break; 073 case GroovyTokenTypes.BXOR_ASSIGN : v.visitBxorAssign(ast,n); break; 074 case GroovyTokenTypes.CASE_GROUP : v.visitCaseGroup(ast,n); break; 075 case GroovyTokenTypes.CLASS_DEF : v.visitClassDef(ast,n); break; 076 case GroovyTokenTypes.CLOSED_BLOCK : v.visitClosedBlock(ast,n); break; 077 case GroovyTokenTypes.CLOSURE_OP : v.visitClosureOp(ast,n); break; 078 case GroovyTokenTypes.COLON : v.visitColon(ast,n); break; 079 case GroovyTokenTypes.COMMA : v.visitComma(ast,n); break; 080 case GroovyTokenTypes.COMPARE_TO : v.visitCompareTo(ast,n); break; 081 case GroovyTokenTypes.CTOR_CALL : v.visitCtorCall(ast,n); break; 082 case GroovyTokenTypes.CTOR_IDENT : v.visitCtorIdent(ast,n); break; 083 case GroovyTokenTypes.DEC : v.visitDec(ast,n); break; 084 case GroovyTokenTypes.DIGIT : v.visitDigit(ast,n); break; 085 case GroovyTokenTypes.DIV : v.visitDiv(ast,n); break; 086 case GroovyTokenTypes.DIV_ASSIGN : v.visitDivAssign(ast,n); break; 087 case GroovyTokenTypes.DOLLAR : v.visitDollar(ast,n); break; 088 case GroovyTokenTypes.DOT : v.visitDot(ast,n); break; 089 case GroovyTokenTypes.DYNAMIC_MEMBER : v.visitDynamicMember(ast,n); break; 090 case GroovyTokenTypes.ELIST : v.visitElist(ast,n); break; 091 case GroovyTokenTypes.EMPTY_STAT : v.visitEmptyStat(ast,n); break; 092 case GroovyTokenTypes.ENUM_CONSTANT_DEF : v.visitEnumConstantDef(ast,n); break; 093 case GroovyTokenTypes.ENUM_DEF : v.visitEnumDef(ast,n); break; 094 case GroovyTokenTypes.EOF : v.visitEof(ast,n); break; 095 case GroovyTokenTypes.EQUAL : v.visitEqual(ast,n); break; 096 case GroovyTokenTypes.ESC : v.visitEsc(ast,n); break; 097 case GroovyTokenTypes.EXPONENT : v.visitExponent(ast,n); break; 098 case GroovyTokenTypes.EXPR : v.visitExpr(ast,n); break; 099 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 }