Source Code Cross Referenced for CompositeVisitor.java in  » Scripting » groovy-1.0 » org » codehaus » groovy » antlr » treewalker » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Scripting » groovy 1.0 » org.codehaus.groovy.antlr.treewalker 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.