0001: /**
0002: *
0003: * Copyright 2005 Jeremy Rayner
0004: *
0005: * Licensed under the Apache License, Version 2.0 (the "License");
0006: * you may not use this file except in compliance with the License.
0007: * You may obtain a copy of the License at
0008: *
0009: * http://www.apache.org/licenses/LICENSE-2.0
0010: *
0011: * Unless required by applicable law or agreed to in writing, software
0012: * distributed under the License is distributed on an "AS IS" BASIS,
0013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014: * See the License for the specific language governing permissions and
0015: * limitations under the License.
0016: *
0017: **/package org.codehaus.groovy.antlr.treewalker;
0018:
0019: import java.util.*;
0020:
0021: import org.codehaus.groovy.antlr.GroovySourceAST;
0022:
0023: /**
0024: * A composite of many visitors. Any call to a method from Visitor
0025: * will invoke each visitor in turn, and reverse the invocation
0026: * order on a closing visit.
0027: * i.e.
0028: * with the list of visitors = [a,b,c]
0029: * composite.visitDefault() would...
0030: * call on the opening visit - a.visitDefault() then b.visitDefault() then c.visitDefault()
0031: * call on the closing visit - c.visitDefault() then b.visitDefault() then a.visitDefault()
0032: *
0033: * @author <a href="mailto:groovy@ross-rayner.com">Jeremy Rayner</a>
0034: * @version $Revision: 3626 $
0035: */
0036:
0037: public class CompositeVisitor implements Visitor {
0038: List visitors;
0039: List backToFrontVisitors;
0040: private Stack stack;
0041:
0042: /**
0043: * A composite of the supplied list of antlr AST visitors.
0044: * @param visitors a List of implementations of the Visitor interface
0045: */
0046: public CompositeVisitor(List visitors) {
0047: this .visitors = visitors;
0048: this .stack = new Stack();
0049: backToFrontVisitors = new ArrayList();
0050: backToFrontVisitors.addAll(visitors);
0051: Collections.reverse(backToFrontVisitors);
0052: }
0053:
0054: private Iterator itr(int visit) {
0055: Iterator itr = visitors.iterator();
0056: if (visit == CLOSING_VISIT) {
0057: itr = backToFrontVisitors.iterator();
0058: }
0059: return itr;
0060: }
0061:
0062: public void setUp() {
0063: Iterator itr = visitors.iterator();
0064: while (itr.hasNext()) {
0065: ((Visitor) itr.next()).setUp();
0066: }
0067: }
0068:
0069: public void visitAbstract(GroovySourceAST t, int visit) {
0070: Iterator itr = itr(visit);
0071: while (itr.hasNext()) {
0072: ((Visitor) itr.next()).visitAbstract(t, visit);
0073: }
0074: }
0075:
0076: public void visitAnnotation(GroovySourceAST t, int visit) {
0077: Iterator itr = itr(visit);
0078: while (itr.hasNext()) {
0079: ((Visitor) itr.next()).visitAnnotation(t, visit);
0080: }
0081: }
0082:
0083: public void visitAnnotations(GroovySourceAST t, int visit) {
0084: Iterator itr = itr(visit);
0085: while (itr.hasNext()) {
0086: ((Visitor) itr.next()).visitAnnotations(t, visit);
0087: }
0088: }
0089:
0090: public void visitAnnotationArrayInit(GroovySourceAST t, int visit) {
0091: Iterator itr = itr(visit);
0092: while (itr.hasNext()) {
0093: ((Visitor) itr.next()).visitAnnotationArrayInit(t, visit);
0094: }
0095: }
0096:
0097: public void visitAnnotationDef(GroovySourceAST t, int visit) {
0098: Iterator itr = itr(visit);
0099: while (itr.hasNext()) {
0100: ((Visitor) itr.next()).visitAnnotationDef(t, visit);
0101: }
0102: }
0103:
0104: public void visitAnnotationFieldDef(GroovySourceAST t, int visit) {
0105: Iterator itr = itr(visit);
0106: while (itr.hasNext()) {
0107: ((Visitor) itr.next()).visitAnnotationFieldDef(t, visit);
0108: }
0109: }
0110:
0111: public void visitAnnotationMemberValuePair(GroovySourceAST t,
0112: int visit) {
0113: Iterator itr = itr(visit);
0114: while (itr.hasNext()) {
0115: ((Visitor) itr.next()).visitAnnotationMemberValuePair(t,
0116: visit);
0117: }
0118: }
0119:
0120: public void visitArrayDeclarator(GroovySourceAST t, int visit) {
0121: Iterator itr = itr(visit);
0122: while (itr.hasNext()) {
0123: ((Visitor) itr.next()).visitArrayDeclarator(t, visit);
0124: }
0125: }
0126:
0127: public void visitAssign(GroovySourceAST t, int visit) {
0128: Iterator itr = itr(visit);
0129: while (itr.hasNext()) {
0130: ((Visitor) itr.next()).visitAssign(t, visit);
0131: }
0132: }
0133:
0134: public void visitAt(GroovySourceAST t, int visit) {
0135: Iterator itr = itr(visit);
0136: while (itr.hasNext()) {
0137: ((Visitor) itr.next()).visitAt(t, visit);
0138: }
0139: }
0140:
0141: public void visitBand(GroovySourceAST t, int visit) {
0142: Iterator itr = itr(visit);
0143: while (itr.hasNext()) {
0144: ((Visitor) itr.next()).visitBand(t, visit);
0145: }
0146: }
0147:
0148: public void visitBandAssign(GroovySourceAST t, int visit) {
0149: Iterator itr = itr(visit);
0150: while (itr.hasNext()) {
0151: ((Visitor) itr.next()).visitBandAssign(t, visit);
0152: }
0153: }
0154:
0155: public void visitBigSuffix(GroovySourceAST t, int visit) {
0156: Iterator itr = itr(visit);
0157: while (itr.hasNext()) {
0158: ((Visitor) itr.next()).visitBigSuffix(t, visit);
0159: }
0160: }
0161:
0162: public void visitBlock(GroovySourceAST t, int visit) {
0163: Iterator itr = itr(visit);
0164: while (itr.hasNext()) {
0165: ((Visitor) itr.next()).visitBlock(t, visit);
0166: }
0167: }
0168:
0169: public void visitBnot(GroovySourceAST t, int visit) {
0170: Iterator itr = itr(visit);
0171: while (itr.hasNext()) {
0172: ((Visitor) itr.next()).visitBnot(t, visit);
0173: }
0174: }
0175:
0176: public void visitBor(GroovySourceAST t, int visit) {
0177: Iterator itr = itr(visit);
0178: while (itr.hasNext()) {
0179: ((Visitor) itr.next()).visitBor(t, visit);
0180: }
0181: }
0182:
0183: public void visitBorAssign(GroovySourceAST t, int visit) {
0184: Iterator itr = itr(visit);
0185: while (itr.hasNext()) {
0186: ((Visitor) itr.next()).visitBorAssign(t, visit);
0187: }
0188: }
0189:
0190: public void visitBsr(GroovySourceAST t, int visit) {
0191: Iterator itr = itr(visit);
0192: while (itr.hasNext()) {
0193: ((Visitor) itr.next()).visitBsr(t, visit);
0194: }
0195: }
0196:
0197: public void visitBsrAssign(GroovySourceAST t, int visit) {
0198: Iterator itr = itr(visit);
0199: while (itr.hasNext()) {
0200: ((Visitor) itr.next()).visitBsrAssign(t, visit);
0201: }
0202: }
0203:
0204: public void visitBxor(GroovySourceAST t, int visit) {
0205: Iterator itr = itr(visit);
0206: while (itr.hasNext()) {
0207: ((Visitor) itr.next()).visitBxor(t, visit);
0208: }
0209: }
0210:
0211: public void visitBxorAssign(GroovySourceAST t, int visit) {
0212: Iterator itr = itr(visit);
0213: while (itr.hasNext()) {
0214: ((Visitor) itr.next()).visitBxorAssign(t, visit);
0215: }
0216: }
0217:
0218: public void visitCaseGroup(GroovySourceAST t, int visit) {
0219: Iterator itr = itr(visit);
0220: while (itr.hasNext()) {
0221: ((Visitor) itr.next()).visitCaseGroup(t, visit);
0222: }
0223: }
0224:
0225: public void visitClassDef(GroovySourceAST t, int visit) {
0226: Iterator itr = itr(visit);
0227: while (itr.hasNext()) {
0228: ((Visitor) itr.next()).visitClassDef(t, visit);
0229: }
0230: }
0231:
0232: public void visitClosedBlock(GroovySourceAST t, int visit) {
0233: Iterator itr = itr(visit);
0234: while (itr.hasNext()) {
0235: ((Visitor) itr.next()).visitClosedBlock(t, visit);
0236: }
0237: }
0238:
0239: public void visitClosureOp(GroovySourceAST t, int visit) {
0240: Iterator itr = itr(visit);
0241: while (itr.hasNext()) {
0242: ((Visitor) itr.next()).visitClosureOp(t, visit);
0243: }
0244: }
0245:
0246: public void visitColon(GroovySourceAST t, int visit) {
0247: Iterator itr = itr(visit);
0248: while (itr.hasNext()) {
0249: ((Visitor) itr.next()).visitColon(t, visit);
0250: }
0251: }
0252:
0253: public void visitComma(GroovySourceAST t, int visit) {
0254: Iterator itr = itr(visit);
0255: while (itr.hasNext()) {
0256: ((Visitor) itr.next()).visitComma(t, visit);
0257: }
0258: }
0259:
0260: public void visitCompareTo(GroovySourceAST t, int visit) {
0261: Iterator itr = itr(visit);
0262: while (itr.hasNext()) {
0263: ((Visitor) itr.next()).visitCompareTo(t, visit);
0264: }
0265: }
0266:
0267: public void visitCtorCall(GroovySourceAST t, int visit) {
0268: Iterator itr = itr(visit);
0269: while (itr.hasNext()) {
0270: ((Visitor) itr.next()).visitCtorCall(t, visit);
0271: }
0272: }
0273:
0274: public void visitCtorIdent(GroovySourceAST t, int visit) {
0275: Iterator itr = itr(visit);
0276: while (itr.hasNext()) {
0277: ((Visitor) itr.next()).visitCtorIdent(t, visit);
0278: }
0279: }
0280:
0281: public void visitDec(GroovySourceAST t, int visit) {
0282: Iterator itr = itr(visit);
0283: while (itr.hasNext()) {
0284: ((Visitor) itr.next()).visitDec(t, visit);
0285: }
0286: }
0287:
0288: public void visitDigit(GroovySourceAST t, int visit) {
0289: Iterator itr = itr(visit);
0290: while (itr.hasNext()) {
0291: ((Visitor) itr.next()).visitDigit(t, visit);
0292: }
0293: }
0294:
0295: public void visitDiv(GroovySourceAST t, int visit) {
0296: Iterator itr = itr(visit);
0297: while (itr.hasNext()) {
0298: ((Visitor) itr.next()).visitDiv(t, visit);
0299: }
0300: }
0301:
0302: public void visitDivAssign(GroovySourceAST t, int visit) {
0303: Iterator itr = itr(visit);
0304: while (itr.hasNext()) {
0305: ((Visitor) itr.next()).visitDivAssign(t, visit);
0306: }
0307: }
0308:
0309: public void visitDollar(GroovySourceAST t, int visit) {
0310: Iterator itr = itr(visit);
0311: while (itr.hasNext()) {
0312: ((Visitor) itr.next()).visitDollar(t, visit);
0313: }
0314: }
0315:
0316: public void visitDot(GroovySourceAST t, int visit) {
0317: Iterator itr = itr(visit);
0318: while (itr.hasNext()) {
0319: ((Visitor) itr.next()).visitDot(t, visit);
0320: }
0321: }
0322:
0323: public void visitDynamicMember(GroovySourceAST t, int visit) {
0324: Iterator itr = itr(visit);
0325: while (itr.hasNext()) {
0326: ((Visitor) itr.next()).visitDynamicMember(t, visit);
0327: }
0328: }
0329:
0330: public void visitElist(GroovySourceAST t, int visit) {
0331: Iterator itr = itr(visit);
0332: while (itr.hasNext()) {
0333: ((Visitor) itr.next()).visitElist(t, visit);
0334: }
0335: }
0336:
0337: public void visitEmptyStat(GroovySourceAST t, int visit) {
0338: Iterator itr = itr(visit);
0339: while (itr.hasNext()) {
0340: ((Visitor) itr.next()).visitEmptyStat(t, visit);
0341: }
0342: }
0343:
0344: public void visitEnumConstantDef(GroovySourceAST t, int visit) {
0345: Iterator itr = itr(visit);
0346: while (itr.hasNext()) {
0347: ((Visitor) itr.next()).visitEnumConstantDef(t, visit);
0348: }
0349: }
0350:
0351: public void visitEnumDef(GroovySourceAST t, int visit) {
0352: Iterator itr = itr(visit);
0353: while (itr.hasNext()) {
0354: ((Visitor) itr.next()).visitEnumDef(t, visit);
0355: }
0356: }
0357:
0358: public void visitEof(GroovySourceAST t, int visit) {
0359: Iterator itr = itr(visit);
0360: while (itr.hasNext()) {
0361: ((Visitor) itr.next()).visitEof(t, visit);
0362: }
0363: }
0364:
0365: public void visitEqual(GroovySourceAST t, int visit) {
0366: Iterator itr = itr(visit);
0367: while (itr.hasNext()) {
0368: ((Visitor) itr.next()).visitEqual(t, visit);
0369: }
0370: }
0371:
0372: public void visitEsc(GroovySourceAST t, int visit) {
0373: Iterator itr = itr(visit);
0374: while (itr.hasNext()) {
0375: ((Visitor) itr.next()).visitEsc(t, visit);
0376: }
0377: }
0378:
0379: public void visitExponent(GroovySourceAST t, int visit) {
0380: Iterator itr = itr(visit);
0381: while (itr.hasNext()) {
0382: ((Visitor) itr.next()).visitExponent(t, visit);
0383: }
0384: }
0385:
0386: public void visitExpr(GroovySourceAST t, int visit) {
0387: Iterator itr = itr(visit);
0388: while (itr.hasNext()) {
0389: ((Visitor) itr.next()).visitExpr(t, visit);
0390: }
0391: }
0392:
0393: public void visitExtendsClause(GroovySourceAST t, int visit) {
0394: Iterator itr = itr(visit);
0395: while (itr.hasNext()) {
0396: ((Visitor) itr.next()).visitExtendsClause(t, visit);
0397: }
0398: }
0399:
0400: public void visitFinal(GroovySourceAST t, int visit) {
0401: Iterator itr = itr(visit);
0402: while (itr.hasNext()) {
0403: ((Visitor) itr.next()).visitFinal(t, visit);
0404: }
0405: }
0406:
0407: public void visitFloatSuffix(GroovySourceAST t, int visit) {
0408: Iterator itr = itr(visit);
0409: while (itr.hasNext()) {
0410: ((Visitor) itr.next()).visitFloatSuffix(t, visit);
0411: }
0412: }
0413:
0414: public void visitForCondition(GroovySourceAST t, int visit) {
0415: Iterator itr = itr(visit);
0416: while (itr.hasNext()) {
0417: ((Visitor) itr.next()).visitForCondition(t, visit);
0418: }
0419: }
0420:
0421: public void visitForEachClause(GroovySourceAST t, int visit) {
0422: Iterator itr = itr(visit);
0423: while (itr.hasNext()) {
0424: ((Visitor) itr.next()).visitForEachClause(t, visit);
0425: }
0426: }
0427:
0428: public void visitForInit(GroovySourceAST t, int visit) {
0429: Iterator itr = itr(visit);
0430: while (itr.hasNext()) {
0431: ((Visitor) itr.next()).visitForInit(t, visit);
0432: }
0433: }
0434:
0435: public void visitForInIterable(GroovySourceAST t, int visit) {
0436: Iterator itr = itr(visit);
0437: while (itr.hasNext()) {
0438: ((Visitor) itr.next()).visitForInIterable(t, visit);
0439: }
0440: }
0441:
0442: public void visitForIterator(GroovySourceAST t, int visit) {
0443: Iterator itr = itr(visit);
0444: while (itr.hasNext()) {
0445: ((Visitor) itr.next()).visitForIterator(t, visit);
0446: }
0447: }
0448:
0449: public void visitGe(GroovySourceAST t, int visit) {
0450: Iterator itr = itr(visit);
0451: while (itr.hasNext()) {
0452: ((Visitor) itr.next()).visitGe(t, visit);
0453: }
0454: }
0455:
0456: public void visitGt(GroovySourceAST t, int visit) {
0457: Iterator itr = itr(visit);
0458: while (itr.hasNext()) {
0459: ((Visitor) itr.next()).visitGt(t, visit);
0460: }
0461: }
0462:
0463: public void visitHexDigit(GroovySourceAST t, int visit) {
0464: Iterator itr = itr(visit);
0465: while (itr.hasNext()) {
0466: ((Visitor) itr.next()).visitHexDigit(t, visit);
0467: }
0468: }
0469:
0470: public void visitIdent(GroovySourceAST t, int visit) {
0471: Iterator itr = itr(visit);
0472: while (itr.hasNext()) {
0473: ((Visitor) itr.next()).visitIdent(t, visit);
0474: }
0475: }
0476:
0477: public void visitImplementsClause(GroovySourceAST t, int visit) {
0478: Iterator itr = itr(visit);
0479: while (itr.hasNext()) {
0480: ((Visitor) itr.next()).visitImplementsClause(t, visit);
0481: }
0482: }
0483:
0484: public void visitImplicitParameters(GroovySourceAST t, int visit) {
0485: Iterator itr = itr(visit);
0486: while (itr.hasNext()) {
0487: ((Visitor) itr.next()).visitImplicitParameters(t, visit);
0488: }
0489: }
0490:
0491: public void visitImport(GroovySourceAST t, int visit) {
0492: Iterator itr = itr(visit);
0493: while (itr.hasNext()) {
0494: ((Visitor) itr.next()).visitImport(t, visit);
0495: }
0496: }
0497:
0498: public void visitInc(GroovySourceAST t, int visit) {
0499: Iterator itr = itr(visit);
0500: while (itr.hasNext()) {
0501: ((Visitor) itr.next()).visitInc(t, visit);
0502: }
0503: }
0504:
0505: public void visitIndexOp(GroovySourceAST t, int visit) {
0506: Iterator itr = itr(visit);
0507: while (itr.hasNext()) {
0508: ((Visitor) itr.next()).visitIndexOp(t, visit);
0509: }
0510: }
0511:
0512: public void visitInstanceInit(GroovySourceAST t, int visit) {
0513: Iterator itr = itr(visit);
0514: while (itr.hasNext()) {
0515: ((Visitor) itr.next()).visitInstanceInit(t, visit);
0516: }
0517: }
0518:
0519: public void visitInterfaceDef(GroovySourceAST t, int visit) {
0520: Iterator itr = itr(visit);
0521: while (itr.hasNext()) {
0522: ((Visitor) itr.next()).visitInterfaceDef(t, visit);
0523: }
0524: }
0525:
0526: public void visitLabeledArg(GroovySourceAST t, int visit) {
0527: Iterator itr = itr(visit);
0528: while (itr.hasNext()) {
0529: ((Visitor) itr.next()).visitLabeledArg(t, visit);
0530: }
0531: }
0532:
0533: public void visitLabeledStat(GroovySourceAST t, int visit) {
0534: Iterator itr = itr(visit);
0535: while (itr.hasNext()) {
0536: ((Visitor) itr.next()).visitLabeledStat(t, visit);
0537: }
0538: }
0539:
0540: public void visitLand(GroovySourceAST t, int visit) {
0541: Iterator itr = itr(visit);
0542: while (itr.hasNext()) {
0543: ((Visitor) itr.next()).visitLand(t, visit);
0544: }
0545: }
0546:
0547: public void visitLbrack(GroovySourceAST t, int visit) {
0548: Iterator itr = itr(visit);
0549: while (itr.hasNext()) {
0550: ((Visitor) itr.next()).visitLbrack(t, visit);
0551: }
0552: }
0553:
0554: public void visitLcurly(GroovySourceAST t, int visit) {
0555: Iterator itr = itr(visit);
0556: while (itr.hasNext()) {
0557: ((Visitor) itr.next()).visitLcurly(t, visit);
0558: }
0559: }
0560:
0561: public void visitLe(GroovySourceAST t, int visit) {
0562: Iterator itr = itr(visit);
0563: while (itr.hasNext()) {
0564: ((Visitor) itr.next()).visitLe(t, visit);
0565: }
0566: }
0567:
0568: public void visitLetter(GroovySourceAST t, int visit) {
0569: Iterator itr = itr(visit);
0570: while (itr.hasNext()) {
0571: ((Visitor) itr.next()).visitLetter(t, visit);
0572: }
0573: }
0574:
0575: public void visitListConstructor(GroovySourceAST t, int visit) {
0576: Iterator itr = itr(visit);
0577: while (itr.hasNext()) {
0578: ((Visitor) itr.next()).visitListConstructor(t, visit);
0579: }
0580: }
0581:
0582: public void visitLiteralAny(GroovySourceAST t, int visit) {
0583: Iterator itr = itr(visit);
0584: while (itr.hasNext()) {
0585: ((Visitor) itr.next()).visitLiteralAny(t, visit);
0586: }
0587: }
0588:
0589: public void visitLiteralAs(GroovySourceAST t, int visit) {
0590: Iterator itr = itr(visit);
0591: while (itr.hasNext()) {
0592: ((Visitor) itr.next()).visitLiteralAs(t, visit);
0593: }
0594: }
0595:
0596: public void visitLiteralAssert(GroovySourceAST t, int visit) {
0597: Iterator itr = itr(visit);
0598: while (itr.hasNext()) {
0599: ((Visitor) itr.next()).visitLiteralAssert(t, visit);
0600: }
0601: }
0602:
0603: public void visitLiteralBoolean(GroovySourceAST t, int visit) {
0604: Iterator itr = itr(visit);
0605: while (itr.hasNext()) {
0606: ((Visitor) itr.next()).visitLiteralBoolean(t, visit);
0607: }
0608: }
0609:
0610: public void visitLiteralBreak(GroovySourceAST t, int visit) {
0611: Iterator itr = itr(visit);
0612: while (itr.hasNext()) {
0613: ((Visitor) itr.next()).visitLiteralBreak(t, visit);
0614: }
0615: }
0616:
0617: public void visitLiteralByte(GroovySourceAST t, int visit) {
0618: Iterator itr = itr(visit);
0619: while (itr.hasNext()) {
0620: ((Visitor) itr.next()).visitLiteralByte(t, visit);
0621: }
0622: }
0623:
0624: public void visitLiteralCase(GroovySourceAST t, int visit) {
0625: Iterator itr = itr(visit);
0626: while (itr.hasNext()) {
0627: ((Visitor) itr.next()).visitLiteralCase(t, visit);
0628: }
0629: }
0630:
0631: public void visitLiteralCatch(GroovySourceAST t, int visit) {
0632: Iterator itr = itr(visit);
0633: while (itr.hasNext()) {
0634: ((Visitor) itr.next()).visitLiteralCatch(t, visit);
0635: }
0636: }
0637:
0638: public void visitLiteralChar(GroovySourceAST t, int visit) {
0639: Iterator itr = itr(visit);
0640: while (itr.hasNext()) {
0641: ((Visitor) itr.next()).visitLiteralChar(t, visit);
0642: }
0643: }
0644:
0645: public void visitLiteralClass(GroovySourceAST t, int visit) {
0646: Iterator itr = itr(visit);
0647: while (itr.hasNext()) {
0648: ((Visitor) itr.next()).visitLiteralClass(t, visit);
0649: }
0650: }
0651:
0652: public void visitLiteralContinue(GroovySourceAST t, int visit) {
0653: Iterator itr = itr(visit);
0654: while (itr.hasNext()) {
0655: ((Visitor) itr.next()).visitLiteralContinue(t, visit);
0656: }
0657: }
0658:
0659: public void visitLiteralDef(GroovySourceAST t, int visit) {
0660: Iterator itr = itr(visit);
0661: while (itr.hasNext()) {
0662: ((Visitor) itr.next()).visitLiteralDef(t, visit);
0663: }
0664: }
0665:
0666: public void visitLiteralDefault(GroovySourceAST t, int visit) {
0667: Iterator itr = itr(visit);
0668: while (itr.hasNext()) {
0669: ((Visitor) itr.next()).visitLiteralDefault(t, visit);
0670: }
0671: }
0672:
0673: public void visitLiteralDouble(GroovySourceAST t, int visit) {
0674: Iterator itr = itr(visit);
0675: while (itr.hasNext()) {
0676: ((Visitor) itr.next()).visitLiteralDouble(t, visit);
0677: }
0678: }
0679:
0680: public void visitLiteralElse(GroovySourceAST t, int visit) {
0681: Iterator itr = itr(visit);
0682: while (itr.hasNext()) {
0683: ((Visitor) itr.next()).visitLiteralElse(t, visit);
0684: }
0685: }
0686:
0687: public void visitLiteralEnum(GroovySourceAST t, int visit) {
0688: Iterator itr = itr(visit);
0689: while (itr.hasNext()) {
0690: ((Visitor) itr.next()).visitLiteralEnum(t, visit);
0691: }
0692: }
0693:
0694: public void visitLiteralExtends(GroovySourceAST t, int visit) {
0695: Iterator itr = itr(visit);
0696: while (itr.hasNext()) {
0697: ((Visitor) itr.next()).visitLiteralExtends(t, visit);
0698: }
0699: }
0700:
0701: public void visitLiteralFalse(GroovySourceAST t, int visit) {
0702: Iterator itr = itr(visit);
0703: while (itr.hasNext()) {
0704: ((Visitor) itr.next()).visitLiteralFalse(t, visit);
0705: }
0706: }
0707:
0708: public void visitLiteralFinally(GroovySourceAST t, int visit) {
0709: Iterator itr = itr(visit);
0710: while (itr.hasNext()) {
0711: ((Visitor) itr.next()).visitLiteralFinally(t, visit);
0712: }
0713: }
0714:
0715: public void visitLiteralFloat(GroovySourceAST t, int visit) {
0716: Iterator itr = itr(visit);
0717: while (itr.hasNext()) {
0718: ((Visitor) itr.next()).visitLiteralFloat(t, visit);
0719: }
0720: }
0721:
0722: public void visitLiteralFor(GroovySourceAST t, int visit) {
0723: Iterator itr = itr(visit);
0724: while (itr.hasNext()) {
0725: ((Visitor) itr.next()).visitLiteralFor(t, visit);
0726: }
0727: }
0728:
0729: public void visitLiteralIf(GroovySourceAST t, int visit) {
0730: Iterator itr = itr(visit);
0731: while (itr.hasNext()) {
0732: ((Visitor) itr.next()).visitLiteralIf(t, visit);
0733: }
0734: }
0735:
0736: public void visitLiteralImplements(GroovySourceAST t, int visit) {
0737: Iterator itr = itr(visit);
0738: while (itr.hasNext()) {
0739: ((Visitor) itr.next()).visitLiteralImplements(t, visit);
0740: }
0741: }
0742:
0743: public void visitLiteralImport(GroovySourceAST t, int visit) {
0744: Iterator itr = itr(visit);
0745: while (itr.hasNext()) {
0746: ((Visitor) itr.next()).visitLiteralImport(t, visit);
0747: }
0748: }
0749:
0750: public void visitLiteralIn(GroovySourceAST t, int visit) {
0751: Iterator itr = itr(visit);
0752: while (itr.hasNext()) {
0753: ((Visitor) itr.next()).visitLiteralIn(t, visit);
0754: }
0755: }
0756:
0757: public void visitLiteralInstanceof(GroovySourceAST t, int visit) {
0758: Iterator itr = itr(visit);
0759: while (itr.hasNext()) {
0760: ((Visitor) itr.next()).visitLiteralInstanceof(t, visit);
0761: }
0762: }
0763:
0764: public void visitLiteralInt(GroovySourceAST t, int visit) {
0765: Iterator itr = itr(visit);
0766: while (itr.hasNext()) {
0767: ((Visitor) itr.next()).visitLiteralInt(t, visit);
0768: }
0769: }
0770:
0771: public void visitLiteralInterface(GroovySourceAST t, int visit) {
0772: Iterator itr = itr(visit);
0773: while (itr.hasNext()) {
0774: ((Visitor) itr.next()).visitLiteralInterface(t, visit);
0775: }
0776: }
0777:
0778: public void visitLiteralLong(GroovySourceAST t, int visit) {
0779: Iterator itr = itr(visit);
0780: while (itr.hasNext()) {
0781: ((Visitor) itr.next()).visitLiteralLong(t, visit);
0782: }
0783: }
0784:
0785: public void visitLiteralNative(GroovySourceAST t, int visit) {
0786: Iterator itr = itr(visit);
0787: while (itr.hasNext()) {
0788: ((Visitor) itr.next()).visitLiteralNative(t, visit);
0789: }
0790: }
0791:
0792: public void visitLiteralNew(GroovySourceAST t, int visit) {
0793: Iterator itr = itr(visit);
0794: while (itr.hasNext()) {
0795: ((Visitor) itr.next()).visitLiteralNew(t, visit);
0796: }
0797: }
0798:
0799: public void visitLiteralNull(GroovySourceAST t, int visit) {
0800: Iterator itr = itr(visit);
0801: while (itr.hasNext()) {
0802: ((Visitor) itr.next()).visitLiteralNull(t, visit);
0803: }
0804: }
0805:
0806: public void visitLiteralPackage(GroovySourceAST t, int visit) {
0807: Iterator itr = itr(visit);
0808: while (itr.hasNext()) {
0809: ((Visitor) itr.next()).visitLiteralPackage(t, visit);
0810: }
0811: }
0812:
0813: public void visitLiteralPrivate(GroovySourceAST t, int visit) {
0814: Iterator itr = itr(visit);
0815: while (itr.hasNext()) {
0816: ((Visitor) itr.next()).visitLiteralPrivate(t, visit);
0817: }
0818: }
0819:
0820: public void visitLiteralProtected(GroovySourceAST t, int visit) {
0821: Iterator itr = itr(visit);
0822: while (itr.hasNext()) {
0823: ((Visitor) itr.next()).visitLiteralProtected(t, visit);
0824: }
0825: }
0826:
0827: public void visitLiteralPublic(GroovySourceAST t, int visit) {
0828: Iterator itr = itr(visit);
0829: while (itr.hasNext()) {
0830: ((Visitor) itr.next()).visitLiteralPublic(t, visit);
0831: }
0832: }
0833:
0834: public void visitLiteralReturn(GroovySourceAST t, int visit) {
0835: Iterator itr = itr(visit);
0836: while (itr.hasNext()) {
0837: ((Visitor) itr.next()).visitLiteralReturn(t, visit);
0838: }
0839: }
0840:
0841: public void visitLiteralShort(GroovySourceAST t, int visit) {
0842: Iterator itr = itr(visit);
0843: while (itr.hasNext()) {
0844: ((Visitor) itr.next()).visitLiteralShort(t, visit);
0845: }
0846: }
0847:
0848: public void visitLiteralStatic(GroovySourceAST t, int visit) {
0849: Iterator itr = itr(visit);
0850: while (itr.hasNext()) {
0851: ((Visitor) itr.next()).visitLiteralStatic(t, visit);
0852: }
0853: }
0854:
0855: public void visitLiteralSuper(GroovySourceAST t, int visit) {
0856: Iterator itr = itr(visit);
0857: while (itr.hasNext()) {
0858: ((Visitor) itr.next()).visitLiteralSuper(t, visit);
0859: }
0860: }
0861:
0862: public void visitLiteralSwitch(GroovySourceAST t, int visit) {
0863: Iterator itr = itr(visit);
0864: while (itr.hasNext()) {
0865: ((Visitor) itr.next()).visitLiteralSwitch(t, visit);
0866: }
0867: }
0868:
0869: public void visitLiteralSynchronized(GroovySourceAST t, int visit) {
0870: Iterator itr = itr(visit);
0871: while (itr.hasNext()) {
0872: ((Visitor) itr.next()).visitLiteralSynchronized(t, visit);
0873: }
0874: }
0875:
0876: public void visitLiteralThis(GroovySourceAST t, int visit) {
0877: Iterator itr = itr(visit);
0878: while (itr.hasNext()) {
0879: ((Visitor) itr.next()).visitLiteralThis(t, visit);
0880: }
0881: }
0882:
0883: public void visitLiteralThreadsafe(GroovySourceAST t, int visit) {
0884: Iterator itr = itr(visit);
0885: while (itr.hasNext()) {
0886: ((Visitor) itr.next()).visitLiteralThreadsafe(t, visit);
0887: }
0888: }
0889:
0890: public void visitLiteralThrow(GroovySourceAST t, int visit) {
0891: Iterator itr = itr(visit);
0892: while (itr.hasNext()) {
0893: ((Visitor) itr.next()).visitLiteralThrow(t, visit);
0894: }
0895: }
0896:
0897: public void visitLiteralThrows(GroovySourceAST t, int visit) {
0898: Iterator itr = itr(visit);
0899: while (itr.hasNext()) {
0900: ((Visitor) itr.next()).visitLiteralThrows(t, visit);
0901: }
0902: }
0903:
0904: public void visitLiteralTransient(GroovySourceAST t, int visit) {
0905: Iterator itr = itr(visit);
0906: while (itr.hasNext()) {
0907: ((Visitor) itr.next()).visitLiteralTransient(t, visit);
0908: }
0909: }
0910:
0911: public void visitLiteralTrue(GroovySourceAST t, int visit) {
0912: Iterator itr = itr(visit);
0913: while (itr.hasNext()) {
0914: ((Visitor) itr.next()).visitLiteralTrue(t, visit);
0915: }
0916: }
0917:
0918: public void visitLiteralTry(GroovySourceAST t, int visit) {
0919: Iterator itr = itr(visit);
0920: while (itr.hasNext()) {
0921: ((Visitor) itr.next()).visitLiteralTry(t, visit);
0922: }
0923: }
0924:
0925: public void visitLiteralVoid(GroovySourceAST t, int visit) {
0926: Iterator itr = itr(visit);
0927: while (itr.hasNext()) {
0928: ((Visitor) itr.next()).visitLiteralVoid(t, visit);
0929: }
0930: }
0931:
0932: public void visitLiteralVolatile(GroovySourceAST t, int visit) {
0933: Iterator itr = itr(visit);
0934: while (itr.hasNext()) {
0935: ((Visitor) itr.next()).visitLiteralVolatile(t, visit);
0936: }
0937: }
0938:
0939: public void visitLiteralWhile(GroovySourceAST t, int visit) {
0940: Iterator itr = itr(visit);
0941: while (itr.hasNext()) {
0942: ((Visitor) itr.next()).visitLiteralWhile(t, visit);
0943: }
0944: }
0945:
0946: public void visitLiteralWith(GroovySourceAST t, int visit) {
0947: Iterator itr = itr(visit);
0948: while (itr.hasNext()) {
0949: ((Visitor) itr.next()).visitLiteralWith(t, visit);
0950: }
0951: }
0952:
0953: public void visitLnot(GroovySourceAST t, int visit) {
0954: Iterator itr = itr(visit);
0955: while (itr.hasNext()) {
0956: ((Visitor) itr.next()).visitLnot(t, visit);
0957: }
0958: }
0959:
0960: public void visitLor(GroovySourceAST t, int visit) {
0961: Iterator itr = itr(visit);
0962: while (itr.hasNext()) {
0963: ((Visitor) itr.next()).visitLor(t, visit);
0964: }
0965: }
0966:
0967: public void visitLparen(GroovySourceAST t, int visit) {
0968: Iterator itr = itr(visit);
0969: while (itr.hasNext()) {
0970: ((Visitor) itr.next()).visitLparen(t, visit);
0971: }
0972: }
0973:
0974: public void visitLt(GroovySourceAST t, int visit) {
0975: Iterator itr = itr(visit);
0976: while (itr.hasNext()) {
0977: ((Visitor) itr.next()).visitLt(t, visit);
0978: }
0979: }
0980:
0981: public void visitMapConstructor(GroovySourceAST t, int visit) {
0982: Iterator itr = itr(visit);
0983: while (itr.hasNext()) {
0984: ((Visitor) itr.next()).visitMapConstructor(t, visit);
0985: }
0986: }
0987:
0988: public void visitMemberPointer(GroovySourceAST t, int visit) {
0989: Iterator itr = itr(visit);
0990: while (itr.hasNext()) {
0991: ((Visitor) itr.next()).visitMemberPointer(t, visit);
0992: }
0993: }
0994:
0995: public void visitMethodCall(GroovySourceAST t, int visit) {
0996: Iterator itr = itr(visit);
0997: while (itr.hasNext()) {
0998: ((Visitor) itr.next()).visitMethodCall(t, visit);
0999: }
1000: }
1001:
1002: public void visitMethodDef(GroovySourceAST t, int visit) {
1003: Iterator itr = itr(visit);
1004: while (itr.hasNext()) {
1005: ((Visitor) itr.next()).visitMethodDef(t, visit);
1006: }
1007: }
1008:
1009: public void visitMinus(GroovySourceAST t, int visit) {
1010: Iterator itr = itr(visit);
1011: while (itr.hasNext()) {
1012: ((Visitor) itr.next()).visitMinus(t, visit);
1013: }
1014: }
1015:
1016: public void visitMinusAssign(GroovySourceAST t, int visit) {
1017: Iterator itr = itr(visit);
1018: while (itr.hasNext()) {
1019: ((Visitor) itr.next()).visitMinusAssign(t, visit);
1020: }
1021: }
1022:
1023: public void visitMlComment(GroovySourceAST t, int visit) {
1024: Iterator itr = itr(visit);
1025: while (itr.hasNext()) {
1026: ((Visitor) itr.next()).visitMlComment(t, visit);
1027: }
1028: }
1029:
1030: public void visitMod(GroovySourceAST t, int visit) {
1031: Iterator itr = itr(visit);
1032: while (itr.hasNext()) {
1033: ((Visitor) itr.next()).visitMod(t, visit);
1034: }
1035: }
1036:
1037: public void visitModifiers(GroovySourceAST t, int visit) {
1038: Iterator itr = itr(visit);
1039: while (itr.hasNext()) {
1040: ((Visitor) itr.next()).visitModifiers(t, visit);
1041: }
1042: }
1043:
1044: public void visitModAssign(GroovySourceAST t, int visit) {
1045: Iterator itr = itr(visit);
1046: while (itr.hasNext()) {
1047: ((Visitor) itr.next()).visitModAssign(t, visit);
1048: }
1049: }
1050:
1051: public void visitNls(GroovySourceAST t, int visit) {
1052: Iterator itr = itr(visit);
1053: while (itr.hasNext()) {
1054: ((Visitor) itr.next()).visitNls(t, visit);
1055: }
1056: }
1057:
1058: public void visitNotEqual(GroovySourceAST t, int visit) {
1059: Iterator itr = itr(visit);
1060: while (itr.hasNext()) {
1061: ((Visitor) itr.next()).visitNotEqual(t, visit);
1062: }
1063: }
1064:
1065: public void visitNullTreeLookahead(GroovySourceAST t, int visit) {
1066: Iterator itr = itr(visit);
1067: while (itr.hasNext()) {
1068: ((Visitor) itr.next()).visitNullTreeLookahead(t, visit);
1069: }
1070: }
1071:
1072: public void visitNumBigDecimal(GroovySourceAST t, int visit) {
1073: Iterator itr = itr(visit);
1074: while (itr.hasNext()) {
1075: ((Visitor) itr.next()).visitNumBigDecimal(t, visit);
1076: }
1077: }
1078:
1079: public void visitNumBigInt(GroovySourceAST t, int visit) {
1080: Iterator itr = itr(visit);
1081: while (itr.hasNext()) {
1082: ((Visitor) itr.next()).visitNumBigInt(t, visit);
1083: }
1084: }
1085:
1086: public void visitNumDouble(GroovySourceAST t, int visit) {
1087: Iterator itr = itr(visit);
1088: while (itr.hasNext()) {
1089: ((Visitor) itr.next()).visitNumDouble(t, visit);
1090: }
1091: }
1092:
1093: public void visitNumFloat(GroovySourceAST t, int visit) {
1094: Iterator itr = itr(visit);
1095: while (itr.hasNext()) {
1096: ((Visitor) itr.next()).visitNumFloat(t, visit);
1097: }
1098: }
1099:
1100: public void visitNumInt(GroovySourceAST t, int visit) {
1101: Iterator itr = itr(visit);
1102: while (itr.hasNext()) {
1103: ((Visitor) itr.next()).visitNumInt(t, visit);
1104: }
1105: }
1106:
1107: public void visitNumLong(GroovySourceAST t, int visit) {
1108: Iterator itr = itr(visit);
1109: while (itr.hasNext()) {
1110: ((Visitor) itr.next()).visitNumLong(t, visit);
1111: }
1112: }
1113:
1114: public void visitObjblock(GroovySourceAST t, int visit) {
1115: Iterator itr = itr(visit);
1116: while (itr.hasNext()) {
1117: ((Visitor) itr.next()).visitObjblock(t, visit);
1118: }
1119: }
1120:
1121: public void visitOneNl(GroovySourceAST t, int visit) {
1122: Iterator itr = itr(visit);
1123: while (itr.hasNext()) {
1124: ((Visitor) itr.next()).visitOneNl(t, visit);
1125: }
1126: }
1127:
1128: public void visitOptionalDot(GroovySourceAST t, int visit) {
1129: Iterator itr = itr(visit);
1130: while (itr.hasNext()) {
1131: ((Visitor) itr.next()).visitOptionalDot(t, visit);
1132: }
1133: }
1134:
1135: public void visitPackageDef(GroovySourceAST t, int visit) {
1136: Iterator itr = itr(visit);
1137: while (itr.hasNext()) {
1138: ((Visitor) itr.next()).visitPackageDef(t, visit);
1139: }
1140: }
1141:
1142: public void visitParameters(GroovySourceAST t, int visit) {
1143: Iterator itr = itr(visit);
1144: while (itr.hasNext()) {
1145: ((Visitor) itr.next()).visitParameters(t, visit);
1146: }
1147: }
1148:
1149: public void visitParameterDef(GroovySourceAST t, int visit) {
1150: Iterator itr = itr(visit);
1151: while (itr.hasNext()) {
1152: ((Visitor) itr.next()).visitParameterDef(t, visit);
1153: }
1154: }
1155:
1156: public void visitPlus(GroovySourceAST t, int visit) {
1157: Iterator itr = itr(visit);
1158: while (itr.hasNext()) {
1159: ((Visitor) itr.next()).visitPlus(t, visit);
1160: }
1161: }
1162:
1163: public void visitPlusAssign(GroovySourceAST t, int visit) {
1164: Iterator itr = itr(visit);
1165: while (itr.hasNext()) {
1166: ((Visitor) itr.next()).visitPlusAssign(t, visit);
1167: }
1168: }
1169:
1170: public void visitPostDec(GroovySourceAST t, int visit) {
1171: Iterator itr = itr(visit);
1172: while (itr.hasNext()) {
1173: ((Visitor) itr.next()).visitPostDec(t, visit);
1174: }
1175: }
1176:
1177: public void visitPostInc(GroovySourceAST t, int visit) {
1178: Iterator itr = itr(visit);
1179: while (itr.hasNext()) {
1180: ((Visitor) itr.next()).visitPostInc(t, visit);
1181: }
1182: }
1183:
1184: public void visitQuestion(GroovySourceAST t, int visit) {
1185: Iterator itr = itr(visit);
1186: while (itr.hasNext()) {
1187: ((Visitor) itr.next()).visitQuestion(t, visit);
1188: }
1189: }
1190:
1191: public void visitRangeExclusive(GroovySourceAST t, int visit) {
1192: Iterator itr = itr(visit);
1193: while (itr.hasNext()) {
1194: ((Visitor) itr.next()).visitRangeExclusive(t, visit);
1195: }
1196: }
1197:
1198: public void visitRangeInclusive(GroovySourceAST t, int visit) {
1199: Iterator itr = itr(visit);
1200: while (itr.hasNext()) {
1201: ((Visitor) itr.next()).visitRangeInclusive(t, visit);
1202: }
1203: }
1204:
1205: public void visitRbrack(GroovySourceAST t, int visit) {
1206: Iterator itr = itr(visit);
1207: while (itr.hasNext()) {
1208: ((Visitor) itr.next()).visitRbrack(t, visit);
1209: }
1210: }
1211:
1212: public void visitRcurly(GroovySourceAST t, int visit) {
1213: Iterator itr = itr(visit);
1214: while (itr.hasNext()) {
1215: ((Visitor) itr.next()).visitRcurly(t, visit);
1216: }
1217: }
1218:
1219: public void visitRegexpCtorEnd(GroovySourceAST t, int visit) {
1220: Iterator itr = itr(visit);
1221: while (itr.hasNext()) {
1222: ((Visitor) itr.next()).visitRegexpCtorEnd(t, visit);
1223: }
1224: }
1225:
1226: public void visitRegexpLiteral(GroovySourceAST t, int visit) {
1227: Iterator itr = itr(visit);
1228: while (itr.hasNext()) {
1229: ((Visitor) itr.next()).visitRegexpLiteral(t, visit);
1230: }
1231: }
1232:
1233: public void visitRegexpSymbol(GroovySourceAST t, int visit) {
1234: Iterator itr = itr(visit);
1235: while (itr.hasNext()) {
1236: ((Visitor) itr.next()).visitRegexpSymbol(t, visit);
1237: }
1238: }
1239:
1240: public void visitRegexFind(GroovySourceAST t, int visit) {
1241: Iterator itr = itr(visit);
1242: while (itr.hasNext()) {
1243: ((Visitor) itr.next()).visitRegexFind(t, visit);
1244: }
1245: }
1246:
1247: public void visitRegexMatch(GroovySourceAST t, int visit) {
1248: Iterator itr = itr(visit);
1249: while (itr.hasNext()) {
1250: ((Visitor) itr.next()).visitRegexMatch(t, visit);
1251: }
1252: }
1253:
1254: public void visitRparen(GroovySourceAST t, int visit) {
1255: Iterator itr = itr(visit);
1256: while (itr.hasNext()) {
1257: ((Visitor) itr.next()).visitRparen(t, visit);
1258: }
1259: }
1260:
1261: public void visitScopeEscape(GroovySourceAST t, int visit) {
1262: Iterator itr = itr(visit);
1263: while (itr.hasNext()) {
1264: ((Visitor) itr.next()).visitScopeEscape(t, visit);
1265: }
1266: }
1267:
1268: public void visitSelectSlot(GroovySourceAST t, int visit) {
1269: Iterator itr = itr(visit);
1270: while (itr.hasNext()) {
1271: ((Visitor) itr.next()).visitSelectSlot(t, visit);
1272: }
1273: }
1274:
1275: public void visitSemi(GroovySourceAST t, int visit) {
1276: Iterator itr = itr(visit);
1277: while (itr.hasNext()) {
1278: ((Visitor) itr.next()).visitSemi(t, visit);
1279: }
1280: }
1281:
1282: public void visitShComment(GroovySourceAST t, int visit) {
1283: Iterator itr = itr(visit);
1284: while (itr.hasNext()) {
1285: ((Visitor) itr.next()).visitShComment(t, visit);
1286: }
1287: }
1288:
1289: public void visitSl(GroovySourceAST t, int visit) {
1290: Iterator itr = itr(visit);
1291: while (itr.hasNext()) {
1292: ((Visitor) itr.next()).visitSl(t, visit);
1293: }
1294: }
1295:
1296: public void visitSlist(GroovySourceAST t, int visit) {
1297: Iterator itr = itr(visit);
1298: while (itr.hasNext()) {
1299: ((Visitor) itr.next()).visitSlist(t, visit);
1300: }
1301: }
1302:
1303: public void visitSlAssign(GroovySourceAST t, int visit) {
1304: Iterator itr = itr(visit);
1305: while (itr.hasNext()) {
1306: ((Visitor) itr.next()).visitSlAssign(t, visit);
1307: }
1308: }
1309:
1310: public void visitSlComment(GroovySourceAST t, int visit) {
1311: Iterator itr = itr(visit);
1312: while (itr.hasNext()) {
1313: ((Visitor) itr.next()).visitSlComment(t, visit);
1314: }
1315: }
1316:
1317: public void visitSpreadArg(GroovySourceAST t, int visit) {
1318: Iterator itr = itr(visit);
1319: while (itr.hasNext()) {
1320: ((Visitor) itr.next()).visitSpreadArg(t, visit);
1321: }
1322: }
1323:
1324: public void visitSpreadDot(GroovySourceAST t, int visit) {
1325: Iterator itr = itr(visit);
1326: while (itr.hasNext()) {
1327: ((Visitor) itr.next()).visitSpreadDot(t, visit);
1328: }
1329: }
1330:
1331: public void visitSpreadMapArg(GroovySourceAST t, int visit) {
1332: Iterator itr = itr(visit);
1333: while (itr.hasNext()) {
1334: ((Visitor) itr.next()).visitSpreadMapArg(t, visit);
1335: }
1336: }
1337:
1338: public void visitSr(GroovySourceAST t, int visit) {
1339: Iterator itr = itr(visit);
1340: while (itr.hasNext()) {
1341: ((Visitor) itr.next()).visitSr(t, visit);
1342: }
1343: }
1344:
1345: public void visitSrAssign(GroovySourceAST t, int visit) {
1346: Iterator itr = itr(visit);
1347: while (itr.hasNext()) {
1348: ((Visitor) itr.next()).visitSrAssign(t, visit);
1349: }
1350: }
1351:
1352: public void visitStar(GroovySourceAST t, int visit) {
1353: Iterator itr = itr(visit);
1354: while (itr.hasNext()) {
1355: ((Visitor) itr.next()).visitStar(t, visit);
1356: }
1357: }
1358:
1359: public void visitStarAssign(GroovySourceAST t, int visit) {
1360: Iterator itr = itr(visit);
1361: while (itr.hasNext()) {
1362: ((Visitor) itr.next()).visitStarAssign(t, visit);
1363: }
1364: }
1365:
1366: public void visitStarStar(GroovySourceAST t, int visit) {
1367: Iterator itr = itr(visit);
1368: while (itr.hasNext()) {
1369: ((Visitor) itr.next()).visitStarStar(t, visit);
1370: }
1371: }
1372:
1373: public void visitStarStarAssign(GroovySourceAST t, int visit) {
1374: Iterator itr = itr(visit);
1375: while (itr.hasNext()) {
1376: ((Visitor) itr.next()).visitStarStarAssign(t, visit);
1377: }
1378: }
1379:
1380: public void visitStaticImport(GroovySourceAST t, int visit) {
1381: Iterator itr = itr(visit);
1382: while (itr.hasNext()) {
1383: ((Visitor) itr.next()).visitStaticImport(t, visit);
1384: }
1385: }
1386:
1387: public void visitStaticInit(GroovySourceAST t, int visit) {
1388: Iterator itr = itr(visit);
1389: while (itr.hasNext()) {
1390: ((Visitor) itr.next()).visitStaticInit(t, visit);
1391: }
1392: }
1393:
1394: public void visitStrictfp(GroovySourceAST t, int visit) {
1395: Iterator itr = itr(visit);
1396: while (itr.hasNext()) {
1397: ((Visitor) itr.next()).visitStrictfp(t, visit);
1398: }
1399: }
1400:
1401: public void visitStringCh(GroovySourceAST t, int visit) {
1402: Iterator itr = itr(visit);
1403: while (itr.hasNext()) {
1404: ((Visitor) itr.next()).visitStringCh(t, visit);
1405: }
1406: }
1407:
1408: public void visitStringConstructor(GroovySourceAST t, int visit) {
1409: Iterator itr = itr(visit);
1410: while (itr.hasNext()) {
1411: ((Visitor) itr.next()).visitStringConstructor(t, visit);
1412: }
1413: }
1414:
1415: public void visitStringCtorEnd(GroovySourceAST t, int visit) {
1416: Iterator itr = itr(visit);
1417: while (itr.hasNext()) {
1418: ((Visitor) itr.next()).visitStringCtorEnd(t, visit);
1419: }
1420: }
1421:
1422: public void visitStringCtorMiddle(GroovySourceAST t, int visit) {
1423: Iterator itr = itr(visit);
1424: while (itr.hasNext()) {
1425: ((Visitor) itr.next()).visitStringCtorMiddle(t, visit);
1426: }
1427: }
1428:
1429: public void visitStringCtorStart(GroovySourceAST t, int visit) {
1430: Iterator itr = itr(visit);
1431: while (itr.hasNext()) {
1432: ((Visitor) itr.next()).visitStringCtorStart(t, visit);
1433: }
1434: }
1435:
1436: public void visitStringLiteral(GroovySourceAST t, int visit) {
1437: Iterator itr = itr(visit);
1438: while (itr.hasNext()) {
1439: ((Visitor) itr.next()).visitStringLiteral(t, visit);
1440: }
1441: }
1442:
1443: public void visitStringNl(GroovySourceAST t, int visit) {
1444: Iterator itr = itr(visit);
1445: while (itr.hasNext()) {
1446: ((Visitor) itr.next()).visitStringNl(t, visit);
1447: }
1448: }
1449:
1450: public void visitSuperCtorCall(GroovySourceAST t, int visit) {
1451: Iterator itr = itr(visit);
1452: while (itr.hasNext()) {
1453: ((Visitor) itr.next()).visitSuperCtorCall(t, visit);
1454: }
1455: }
1456:
1457: public void visitTripleDot(GroovySourceAST t, int visit) {
1458: Iterator itr = itr(visit);
1459: while (itr.hasNext()) {
1460: ((Visitor) itr.next()).visitTripleDot(t, visit);
1461: }
1462: }
1463:
1464: public void visitType(GroovySourceAST t, int visit) {
1465: Iterator itr = itr(visit);
1466: while (itr.hasNext()) {
1467: ((Visitor) itr.next()).visitType(t, visit);
1468: }
1469: }
1470:
1471: public void visitTypecast(GroovySourceAST t, int visit) {
1472: Iterator itr = itr(visit);
1473: while (itr.hasNext()) {
1474: ((Visitor) itr.next()).visitTypecast(t, visit);
1475: }
1476: }
1477:
1478: public void visitTypeArgument(GroovySourceAST t, int visit) {
1479: Iterator itr = itr(visit);
1480: while (itr.hasNext()) {
1481: ((Visitor) itr.next()).visitTypeArgument(t, visit);
1482: }
1483: }
1484:
1485: public void visitTypeArguments(GroovySourceAST t, int visit) {
1486: Iterator itr = itr(visit);
1487: while (itr.hasNext()) {
1488: ((Visitor) itr.next()).visitTypeArguments(t, visit);
1489: }
1490: }
1491:
1492: public void visitTypeLowerBounds(GroovySourceAST t, int visit) {
1493: Iterator itr = itr(visit);
1494: while (itr.hasNext()) {
1495: ((Visitor) itr.next()).visitTypeLowerBounds(t, visit);
1496: }
1497: }
1498:
1499: public void visitTypeParameter(GroovySourceAST t, int visit) {
1500: Iterator itr = itr(visit);
1501: while (itr.hasNext()) {
1502: ((Visitor) itr.next()).visitTypeParameter(t, visit);
1503: }
1504: }
1505:
1506: public void visitTypeParameters(GroovySourceAST t, int visit) {
1507: Iterator itr = itr(visit);
1508: while (itr.hasNext()) {
1509: ((Visitor) itr.next()).visitTypeParameters(t, visit);
1510: }
1511: }
1512:
1513: public void visitTypeUpperBounds(GroovySourceAST t, int visit) {
1514: Iterator itr = itr(visit);
1515: while (itr.hasNext()) {
1516: ((Visitor) itr.next()).visitTypeUpperBounds(t, visit);
1517: }
1518: }
1519:
1520: public void visitUnaryMinus(GroovySourceAST t, int visit) {
1521: Iterator itr = itr(visit);
1522: while (itr.hasNext()) {
1523: ((Visitor) itr.next()).visitUnaryMinus(t, visit);
1524: }
1525: }
1526:
1527: public void visitUnaryPlus(GroovySourceAST t, int visit) {
1528: Iterator itr = itr(visit);
1529: while (itr.hasNext()) {
1530: ((Visitor) itr.next()).visitUnaryPlus(t, visit);
1531: }
1532: }
1533:
1534: public void visitUnusedConst(GroovySourceAST t, int visit) {
1535: Iterator itr = itr(visit);
1536: while (itr.hasNext()) {
1537: ((Visitor) itr.next()).visitUnusedConst(t, visit);
1538: }
1539: }
1540:
1541: public void visitUnusedDo(GroovySourceAST t, int visit) {
1542: Iterator itr = itr(visit);
1543: while (itr.hasNext()) {
1544: ((Visitor) itr.next()).visitUnusedDo(t, visit);
1545: }
1546: }
1547:
1548: public void visitUnusedGoto(GroovySourceAST t, int visit) {
1549: Iterator itr = itr(visit);
1550: while (itr.hasNext()) {
1551: ((Visitor) itr.next()).visitUnusedGoto(t, visit);
1552: }
1553: }
1554:
1555: public void visitVariableDef(GroovySourceAST t, int visit) {
1556: Iterator itr = itr(visit);
1557: while (itr.hasNext()) {
1558: ((Visitor) itr.next()).visitVariableDef(t, visit);
1559: }
1560: }
1561:
1562: public void visitVariableParameterDef(GroovySourceAST t, int visit) {
1563: Iterator itr = itr(visit);
1564: while (itr.hasNext()) {
1565: ((Visitor) itr.next()).visitVariableParameterDef(t, visit);
1566: }
1567: }
1568:
1569: public void visitVocab(GroovySourceAST t, int visit) {
1570: Iterator itr = itr(visit);
1571: while (itr.hasNext()) {
1572: ((Visitor) itr.next()).visitVocab(t, visit);
1573: }
1574: }
1575:
1576: public void visitWildcardType(GroovySourceAST t, int visit) {
1577: Iterator itr = itr(visit);
1578: while (itr.hasNext()) {
1579: ((Visitor) itr.next()).visitWildcardType(t, visit);
1580: }
1581: }
1582:
1583: public void visitWs(GroovySourceAST t, int visit) {
1584: Iterator itr = itr(visit);
1585: while (itr.hasNext()) {
1586: ((Visitor) itr.next()).visitWs(t, visit);
1587: }
1588: }
1589:
1590: public void visitDefault(GroovySourceAST t, int visit) {
1591: Iterator itr = itr(visit);
1592: while (itr.hasNext()) {
1593: ((Visitor) itr.next()).visitDefault(t, visit);
1594: }
1595: }
1596:
1597: public void tearDown() {
1598: Iterator itr = backToFrontVisitors.iterator();
1599: while (itr.hasNext()) {
1600: ((Visitor) itr.next()).tearDown();
1601: }
1602: }
1603:
1604: public void push(GroovySourceAST t) {
1605: Iterator itr = visitors.iterator();
1606: while (itr.hasNext()) {
1607: ((Visitor) itr.next()).push(t);
1608: }
1609: }
1610:
1611: public GroovySourceAST pop() {
1612: GroovySourceAST lastNodePopped = null;
1613: Iterator itr = backToFrontVisitors.iterator();
1614: while (itr.hasNext()) {
1615: lastNodePopped = (GroovySourceAST) ((Visitor) itr.next())
1616: .pop();
1617: }
1618: return lastNodePopped;
1619: }
1620:
1621: }
|