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