View Javadoc

    1   /***
    2    *
    3    * Copyright 2005 Jeremy Rayner
    4    *
    5    * Licensed under the Apache License, Version 2.0 (the "License");
    6    * you may not use this file except in compliance with the License.
    7    * You may obtain a copy of the License at
    8    *
    9    * http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   *
    17   **/
    18  package org.codehaus.groovy.antlr.treewalker;
    19
    20  import java.util.*;
    21
    22  import org.codehaus.groovy.antlr.GroovySourceAST;
    23
    24  /***
    25   * A composite of many visitors. Any call to a method from Visitor
    26   * will invoke each visitor in turn, and reverse the invocation
    27   * order on a closing visit.
    28   * i.e.
    29   * with the list of visitors = [a,b,c]
    30   * composite.visitDefault() would...
    31   * call on the opening visit - a.visitDefault() then b.visitDefault() then c.visitDefault()
    32   * call on the closing visit - c.visitDefault() then b.visitDefault() then a.visitDefault()
    33   *
    34   * @author <a href="mailto:groovy@ross-rayner.com">Jeremy Rayner</a>
    35   * @version $Revision: 1.2 $
    36   */
    37
    38  public class CompositeVisitor implements Visitor{
    39      List visitors;
    40      List backToFrontVisitors;
    41      private Stack stack;
    42
    43      /***
    44       * A composite of the supplied list of antlr AST visitors.
    45       * @param visitors a List of implementations of the Visitor interface
    46       */
    47      public CompositeVisitor(List visitors) {
    48          this.visitors = visitors;
    49          this.stack = new Stack();
    50          backToFrontVisitors = new ArrayList();
    51          backToFrontVisitors.addAll(visitors);
    52          Collections.reverse(backToFrontVisitors);
    53      }
    54
    55      private Iterator itr(int visit) {
    56          Iterator itr=visitors.iterator();
    57          if (visit == CLOSING_VISIT) {
    58              itr = backToFrontVisitors.iterator();
    59          }
    60          return itr;
    61      }
    62
    63      public void setUp() {
    64          Iterator itr = visitors.iterator();
    65          while (itr.hasNext()) {((Visitor)itr.next()).setUp();}
    66      }
    67
    68      public void visitAbstract(GroovySourceAST t, int visit) {
    69          Iterator itr = itr(visit);
    70          while (itr.hasNext()) {((Visitor)itr.next()).visitAbstract(t,visit);}
    71      }
    72
    73      public void visitAnnotation(GroovySourceAST t, int visit) {
    74          Iterator itr = itr(visit);
    75          while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotation(t,visit);}
    76      }
    77
    78      public void visitAnnotations(GroovySourceAST t, int visit) {
    79          Iterator itr = itr(visit);
    80          while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotations(t,visit);}
    81      }
    82
    83      public void visitAnnotationArrayInit(GroovySourceAST t, int visit) {
    84          Iterator itr = itr(visit);
    85          while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotationArrayInit(t,visit);}
    86      }
    87
    88      public void visitAnnotationDef(GroovySourceAST t, int visit) {
    89          Iterator itr = itr(visit);
    90          while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotationDef(t,visit);}
    91      }
    92
    93      public void visitAnnotationFieldDef(GroovySourceAST t, int visit) {
    94          Iterator itr = itr(visit);
    95          while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotationFieldDef(t,visit);}
    96      }
    97
    98      public void visitAnnotationMemberValuePair(GroovySourceAST t, int visit) {
    99          Iterator itr = itr(visit);
    100         while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotationMemberValuePair(t,visit);}
    101     }
    102
    103     public void visitArrayDeclarator(GroovySourceAST t, int visit) {
    104         Iterator itr = itr(visit);
    105         while (itr.hasNext()) {((Visitor)itr.next()).visitArrayDeclarator(t,visit);}
    106     }
    107
    108     public void visitAssign(GroovySourceAST t, int visit) {
    109         Iterator itr = itr(visit);
    110         while (itr.hasNext()) {((Visitor)itr.next()).visitAssign(t,visit);}
    111     }
    112
    113     public void visitAt(GroovySourceAST t, int visit) {
    114         Iterator itr = itr(visit);
    115         while (itr.hasNext()) {((Visitor)itr.next()).visitAt(t,visit);}
    116     }
    117
    118     public void visitBand(GroovySourceAST t, int visit) {
    119         Iterator itr = itr(visit);
    120         while (itr.hasNext()) {((Visitor)itr.next()).visitBand(t,visit);}
    121     }
    122
    123     public void visitBandAssign(GroovySourceAST t, int visit) {
    124         Iterator itr = itr(visit);
    125         while (itr.hasNext()) {((Visitor)itr.next()).visitBandAssign(t,visit);}
    126     }
    127
    128     public void visitBigSuffix(GroovySourceAST t, int visit) {
    129         Iterator itr = itr(visit);
    130         while (itr.hasNext()) {((Visitor)itr.next()).visitBigSuffix(t,visit);}
    131     }
    132
    133     public void visitBlock(GroovySourceAST t, int visit) {
    134         Iterator itr = itr(visit);
    135         while (itr.hasNext()) {((Visitor)itr.next()).visitBlock(t,visit);}
    136     }
    137
    138     public void visitBnot(GroovySourceAST t, int visit) {
    139         Iterator itr = itr(visit);
    140         while (itr.hasNext()) {((Visitor)itr.next()).visitBnot(t,visit);}
    141     }
    142
    143     public void visitBor(GroovySourceAST t, int visit) {
    144         Iterator itr = itr(visit);
    145         while (itr.hasNext()) {((Visitor)itr.next()).visitBor(t,visit);}
    146     }
    147
    148     public void visitBorAssign(GroovySourceAST t, int visit) {
    149         Iterator itr = itr(visit);
    150         while (itr.hasNext()) {((Visitor)itr.next()).visitBorAssign(t,visit);}
    151     }
    152
    153     public void visitBsr(GroovySourceAST t, int visit) {
    154         Iterator itr = itr(visit);
    155         while (itr.hasNext()) {((Visitor)itr.next()).visitBsr(t,visit);}
    156     }
    157
    158     public void visitBsrAssign(GroovySourceAST t, int visit) {
    159         Iterator itr = itr(visit);
    160         while (itr.hasNext()) {((Visitor)itr.next()).visitBsrAssign(t,visit);}
    161     }
    162
    163     public void visitBxor(GroovySourceAST t, int visit) {
    164         Iterator itr = itr(visit);
    165         while (itr.hasNext()) {((Visitor)itr.next()).visitBxor(t,visit);}
    166     }
    167
    168     public void visitBxorAssign(GroovySourceAST t, int visit) {
    169         Iterator itr = itr(visit);
    170         while (itr.hasNext()) {((Visitor)itr.next()).visitBxorAssign(t,visit);}
    171     }
    172
    173     public void visitCaseGroup(GroovySourceAST t, int visit) {
    174         Iterator itr = itr(visit);
    175         while (itr.hasNext()) {((Visitor)itr.next()).visitCaseGroup(t,visit);}
    176     }
    177
    178     public void visitClassDef(GroovySourceAST t, int visit) {
    179         Iterator itr = itr(visit);
    180         while (itr.hasNext()) {((Visitor)itr.next()).visitClassDef(t,visit);}
    181     }
    182
    183     public void visitClosedBlock(GroovySourceAST t, int visit) {
    184         Iterator itr = itr(visit);
    185         while (itr.hasNext()) {((Visitor)itr.next()).visitClosedBlock(t,visit);}
    186     }
    187
    188     public void visitClosureOp(GroovySourceAST t, int visit) {
    189         Iterator itr = itr(visit);
    190         while (itr.hasNext()) {((Visitor)itr.next()).visitClosureOp(t,visit);}
    191     }
    192
    193     public void visitColon(GroovySourceAST t, int visit) {
    194         Iterator itr = itr(visit);
    195         while (itr.hasNext()) {((Visitor)itr.next()).visitColon(t,visit);}
    196     }
    197
    198     public void visitComma(GroovySourceAST t, int visit) {
    199         Iterator itr = itr(visit);
    200         while (itr.hasNext()) {((Visitor)itr.next()).visitComma(t,visit);}
    201     }
    202
    203     public void visitCompareTo(GroovySourceAST t, int visit) {
    204         Iterator itr = itr(visit);
    205         while (itr.hasNext()) {((Visitor)itr.next()).visitCompareTo(t,visit);}
    206     }
    207
    208     public void visitCtorCall(GroovySourceAST t, int visit) {
    209         Iterator itr = itr(visit);
    210         while (itr.hasNext()) {((Visitor)itr.next()).visitCtorCall(t,visit);}
    211     }
    212
    213     public void visitCtorIdent(GroovySourceAST t, int visit) {
    214         Iterator itr = itr(visit);
    215         while (itr.hasNext()) {((Visitor)itr.next()).visitCtorIdent(t,visit);}
    216     }
    217
    218     public void visitDec(GroovySourceAST t, int visit) {
    219         Iterator itr = itr(visit);
    220         while (itr.hasNext()) {((Visitor)itr.next()).visitDec(t,visit);}
    221     }
    222
    223     public void visitDigit(GroovySourceAST t, int visit) {
    224         Iterator itr = itr(visit);
    225         while (itr.hasNext()) {((Visitor)itr.next()).visitDigit(t,visit);}
    226     }
    227
    228     public void visitDiv(GroovySourceAST t, int visit) {
    229         Iterator itr = itr(visit);
    230         while (itr.hasNext()) {((Visitor)itr.next()).visitDiv(t,visit);}
    231     }
    232
    233     public void visitDivAssign(GroovySourceAST t, int visit) {
    234         Iterator itr = itr(visit);
    235         while (itr.hasNext()) {((Visitor)itr.next()).visitDivAssign(t,visit);}
    236     }
    237
    238     public void visitDollar(GroovySourceAST t, int visit) {
    239         Iterator itr = itr(visit);
    240         while (itr.hasNext()) {((Visitor)itr.next()).visitDollar(t,visit);}
    241     }
    242
    243     public void visitDot(GroovySourceAST t, int visit) {
    244         Iterator itr = itr(visit);
    245         while (itr.hasNext()) {((Visitor)itr.next()).visitDot(t,visit);}
    246     }
    247
    248     public void visitDynamicMember(GroovySourceAST t, int visit) {
    249         Iterator itr = itr(visit);
    250         while (itr.hasNext()) {((Visitor)itr.next()).visitDynamicMember(t,visit);}
    251     }
    252
    253     public void visitElist(GroovySourceAST t, int visit) {
    254         Iterator itr = itr(visit);
    255         while (itr.hasNext()) {((Visitor)itr.next()).visitElist(t,visit);}
    256     }
    257
    258     public void visitEmptyStat(GroovySourceAST t, int visit) {
    259         Iterator itr = itr(visit);
    260         while (itr.hasNext()) {((Visitor)itr.next()).visitEmptyStat(t,visit);}
    261     }
    262
    263     public void visitEnumConstantDef(GroovySourceAST t, int visit) {
    264         Iterator itr = itr(visit);
    265         while (itr.hasNext()) {((Visitor)itr.next()).visitEnumConstantDef(t,visit);}
    266     }
    267
    268     public void visitEnumDef(GroovySourceAST t, int visit) {
    269         Iterator itr = itr(visit);
    270         while (itr.hasNext()) {((Visitor)itr.next()).visitEnumDef(t,visit);}
    271     }
    272
    273     public void visitEof(GroovySourceAST t, int visit) {
    274         Iterator itr = itr(visit);
    275         while (itr.hasNext()) {((Visitor)itr.next()).visitEof(t,visit);}
    276     }
    277
    278     public void visitEqual(GroovySourceAST t, int visit) {
    279         Iterator itr = itr(visit);
    280         while (itr.hasNext()) {((Visitor)itr.next()).visitEqual(t,visit);}
    281     }
    282
    283     public void visitEsc(GroovySourceAST t, int visit) {
    284         Iterator itr = itr(visit);
    285         while (itr.hasNext()) {((Visitor)itr.next()).visitEsc(t,visit);}
    286     }
    287
    288     public void visitExponent(GroovySourceAST t, int visit) {
    289         Iterator itr = itr(visit);
    290         while (itr.hasNext()) {((Visitor)itr.next()).visitExponent(t,visit);}
    291     }
    292
    293     public void visitExpr(GroovySourceAST t, int visit) {
    294         Iterator itr = itr(visit);
    295         while (itr.hasNext()) {((Visitor)itr.next()).visitExpr(t,visit);}
    296     }
    297
    298     public void visitExtendsClause(GroovySourceAST t, int visit) {
    299         Iterator itr = itr(visit);
    300         while (itr.hasNext()) {((Visitor)itr.next()).visitExtendsClause(t,visit);}
    301     }
    302
    303     public void visitFinal(GroovySourceAST t, int visit) {
    304         Iterator itr = itr(visit);
    305         while (itr.hasNext()) {((Visitor)itr.next()).visitFinal(t,visit);}
    306     }
    307
    308     public void visitFloatSuffix(GroovySourceAST t, int visit) {
    309         Iterator itr = itr(visit);
    310         while (itr.hasNext()) {((Visitor)itr.next()).visitFloatSuffix(t,visit);}
    311     }
    312
    313     public void visitForCondition(GroovySourceAST t, int visit) {
    314         Iterator itr = itr(visit);
    315         while (itr.hasNext()) {((Visitor)itr.next()).visitForCondition(t,visit);}
    316     }
    317
    318     public void visitForEachClause(GroovySourceAST t, int visit) {
    319         Iterator itr = itr(visit);
    320         while (itr.hasNext()) {((Visitor)itr.next()).visitForEachClause(t,visit);}
    321     }
    322
    323     public void visitForInit(GroovySourceAST t, int visit) {
    324         Iterator itr = itr(visit);
    325         while (itr.hasNext()) {((Visitor)itr.next()).visitForInit(t,visit);}
    326     }
    327
    328     public void visitForInIterable(GroovySourceAST t, int visit) {
    329         Iterator itr = itr(visit);
    330         while (itr.hasNext()) {((Visitor)itr.next()).visitForInIterable(t,visit);}
    331     }
    332
    333     public void visitForIterator(GroovySourceAST t, int visit) {
    334         Iterator itr = itr(visit);
    335         while (itr.hasNext()) {((Visitor)itr.next()).visitForIterator(t,visit);}
    336     }
    337
    338     public void visitGe(GroovySourceAST t, int visit) {
    339         Iterator itr = itr(visit);
    340         while (itr.hasNext()) {((Visitor)itr.next()).visitGe(t,visit);}
    341     }
    342
    343     public void visitGt(GroovySourceAST t, int visit) {
    344         Iterator itr = itr(visit);
    345         while (itr.hasNext()) {((Visitor)itr.next()).visitGt(t,visit);}
    346     }
    347
    348     public void visitHexDigit(GroovySourceAST t, int visit) {
    349         Iterator itr = itr(visit);
    350         while (itr.hasNext()) {((Visitor)itr.next()).visitHexDigit(t,visit);}
    351     }
    352
    353     public void visitIdent(GroovySourceAST t, int visit) {
    354         Iterator itr = itr(visit);
    355         while (itr.hasNext()) {((Visitor)itr.next()).visitIdent(t,visit);}
    356     }
    357
    358     public void visitImplementsClause(GroovySourceAST t, int visit) {
    359         Iterator itr = itr(visit);
    360         while (itr.hasNext()) {((Visitor)itr.next()).visitImplementsClause(t,visit);}
    361     }
    362
    363     public void visitImplicitParameters(GroovySourceAST t, int visit) {
    364         Iterator itr = itr(visit);
    365         while (itr.hasNext()) {((Visitor)itr.next()).visitImplicitParameters(t,visit);}
    366     }
    367
    368     public void visitImport(GroovySourceAST t, int visit) {
    369         Iterator itr = itr(visit);
    370         while (itr.hasNext()) {((Visitor)itr.next()).visitImport(t,visit);}
    371     }
    372
    373     public void visitInc(GroovySourceAST t, int visit) {
    374         Iterator itr = itr(visit);
    375         while (itr.hasNext()) {((Visitor)itr.next()).visitInc(t,visit);}
    376     }
    377
    378     public void visitIndexOp(GroovySourceAST t, int visit) {
    379         Iterator itr = itr(visit);
    380         while (itr.hasNext()) {((Visitor)itr.next()).visitIndexOp(t,visit);}
    381     }
    382
    383     public void visitInstanceInit(GroovySourceAST t, int visit) {
    384         Iterator itr = itr(visit);
    385         while (itr.hasNext()) {((Visitor)itr.next()).visitInstanceInit(t,visit);}
    386     }
    387
    388     public void visitInterfaceDef(GroovySourceAST t, int visit) {
    389         Iterator itr = itr(visit);
    390         while (itr.hasNext()) {((Visitor)itr.next()).visitInterfaceDef(t,visit);}
    391     }
    392
    393     public void visitLabeledArg(GroovySourceAST t, int visit) {
    394         Iterator itr = itr(visit);
    395         while (itr.hasNext()) {((Visitor)itr.next()).visitLabeledArg(t,visit);}
    396     }
    397
    398     public void visitLabeledStat(GroovySourceAST t, int visit) {
    399         Iterator itr = itr(visit);
    400         while (itr.hasNext()) {((Visitor)itr.next()).visitLabeledStat(t,visit);}
    401     }
    402
    403     public void visitLand(GroovySourceAST t, int visit) {
    404         Iterator itr = itr(visit);
    405         while (itr.hasNext()) {((Visitor)itr.next()).visitLand(t,visit);}
    406     }
    407
    408     public void visitLbrack(GroovySourceAST t, int visit) {
    409         Iterator itr = itr(visit);
    410         while (itr.hasNext()) {((Visitor)itr.next()).visitLbrack(t,visit);}
    411     }
    412
    413     public void visitLcurly(GroovySourceAST t, int visit) {
    414         Iterator itr = itr(visit);
    415         while (itr.hasNext()) {((Visitor)itr.next()).visitLcurly(t,visit);}
    416     }
    417
    418     public void visitLe(GroovySourceAST t, int visit) {
    419         Iterator itr = itr(visit);
    420         while (itr.hasNext()) {((Visitor)itr.next()).visitLe(t,visit);}
    421     }
    422
    423     public void visitLetter(GroovySourceAST t, int visit) {
    424         Iterator itr = itr(visit);
    425         while (itr.hasNext()) {((Visitor)itr.next()).visitLetter(t,visit);}
    426     }
    427
    428     public void visitListConstructor(GroovySourceAST t, int visit) {
    429         Iterator itr = itr(visit);
    430         while (itr.hasNext()) {((Visitor)itr.next()).visitListConstructor(t,visit);}
    431     }
    432
    433     public void visitLiteralAny(GroovySourceAST t, int visit) {
    434         Iterator itr = itr(visit);
    435         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralAny(t,visit);}
    436     }
    437
    438     public void visitLiteralAs(GroovySourceAST t, int visit) {
    439         Iterator itr = itr(visit);
    440         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralAs(t,visit);}
    441     }
    442
    443     public void visitLiteralAssert(GroovySourceAST t, int visit) {
    444         Iterator itr = itr(visit);
    445         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralAssert(t,visit);}
    446     }
    447
    448     public void visitLiteralBoolean(GroovySourceAST t, int visit) {
    449         Iterator itr = itr(visit);
    450         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralBoolean(t,visit);}
    451     }
    452
    453     public void visitLiteralBreak(GroovySourceAST t, int visit) {
    454         Iterator itr = itr(visit);
    455         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralBreak(t,visit);}
    456     }
    457
    458     public void visitLiteralByte(GroovySourceAST t, int visit) {
    459         Iterator itr = itr(visit);
    460         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralByte(t,visit);}
    461     }
    462
    463     public void visitLiteralCase(GroovySourceAST t, int visit) {
    464         Iterator itr = itr(visit);
    465         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralCase(t,visit);}
    466     }
    467
    468     public void visitLiteralCatch(GroovySourceAST t, int visit) {
    469         Iterator itr = itr(visit);
    470         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralCatch(t,visit);}
    471     }
    472
    473     public void visitLiteralChar(GroovySourceAST t, int visit) {
    474         Iterator itr = itr(visit);
    475         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralChar(t,visit);}
    476     }
    477
    478     public void visitLiteralClass(GroovySourceAST t, int visit) {
    479         Iterator itr = itr(visit);
    480         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralClass(t,visit);}
    481     }
    482
    483     public void visitLiteralContinue(GroovySourceAST t, int visit) {
    484         Iterator itr = itr(visit);
    485         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralContinue(t,visit);}
    486     }
    487
    488     public void visitLiteralDef(GroovySourceAST t, int visit) {
    489         Iterator itr = itr(visit);
    490         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralDef(t,visit);}
    491     }
    492
    493     public void visitLiteralDefault(GroovySourceAST t, int visit) {
    494         Iterator itr = itr(visit);
    495         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralDefault(t,visit);}
    496     }
    497
    498     public void visitLiteralDouble(GroovySourceAST t, int visit) {
    499         Iterator itr = itr(visit);
    500         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralDouble(t,visit);}
    501     }
    502
    503     public void visitLiteralElse(GroovySourceAST t, int visit) {
    504         Iterator itr = itr(visit);
    505         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralElse(t,visit);}
    506     }
    507
    508     public void visitLiteralEnum(GroovySourceAST t, int visit) {
    509         Iterator itr = itr(visit);
    510         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralEnum(t,visit);}
    511     }
    512
    513     public void visitLiteralExtends(GroovySourceAST t, int visit) {
    514         Iterator itr = itr(visit);
    515         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralExtends(t,visit);}
    516     }
    517
    518     public void visitLiteralFalse(GroovySourceAST t, int visit) {
    519         Iterator itr = itr(visit);
    520         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralFalse(t,visit);}
    521     }
    522
    523     public void visitLiteralFinally(GroovySourceAST t, int visit) {
    524         Iterator itr = itr(visit);
    525         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralFinally(t,visit);}
    526     }
    527
    528     public void visitLiteralFloat(GroovySourceAST t, int visit) {
    529         Iterator itr = itr(visit);
    530         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralFloat(t,visit);}
    531     }
    532
    533     public void visitLiteralFor(GroovySourceAST t, int visit) {
    534         Iterator itr = itr(visit);
    535         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralFor(t,visit);}
    536     }
    537
    538     public void visitLiteralIf(GroovySourceAST t, int visit) {
    539         Iterator itr = itr(visit);
    540         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralIf(t,visit);}
    541     }
    542
    543     public void visitLiteralImplements(GroovySourceAST t, int visit) {
    544         Iterator itr = itr(visit);
    545         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralImplements(t,visit);}
    546     }
    547
    548     public void visitLiteralImport(GroovySourceAST t, int visit) {
    549         Iterator itr = itr(visit);
    550         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralImport(t,visit);}
    551     }
    552
    553     public void visitLiteralIn(GroovySourceAST t, int visit) {
    554         Iterator itr = itr(visit);
    555         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralIn(t,visit);}
    556     }
    557
    558     public void visitLiteralInstanceof(GroovySourceAST t, int visit) {
    559         Iterator itr = itr(visit);
    560         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralInstanceof(t,visit);}
    561     }
    562
    563     public void visitLiteralInt(GroovySourceAST t, int visit) {
    564         Iterator itr = itr(visit);
    565         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralInt(t,visit);}
    566     }
    567
    568     public void visitLiteralInterface(GroovySourceAST t, int visit) {
    569         Iterator itr = itr(visit);
    570         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralInterface(t,visit);}
    571     }
    572
    573     public void visitLiteralLong(GroovySourceAST t, int visit) {
    574         Iterator itr = itr(visit);
    575         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralLong(t,visit);}
    576     }
    577
    578     public void visitLiteralNative(GroovySourceAST t, int visit) {
    579         Iterator itr = itr(visit);
    580         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralNative(t,visit);}
    581     }
    582
    583     public void visitLiteralNew(GroovySourceAST t, int visit) {
    584         Iterator itr = itr(visit);
    585         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralNew(t,visit);}
    586     }
    587
    588     public void visitLiteralNull(GroovySourceAST t, int visit) {
    589         Iterator itr = itr(visit);
    590         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralNull(t,visit);}
    591     }
    592
    593     public void visitLiteralPackage(GroovySourceAST t, int visit) {
    594         Iterator itr = itr(visit);
    595         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralPackage(t,visit);}
    596     }
    597
    598     public void visitLiteralPrivate(GroovySourceAST t, int visit) {
    599         Iterator itr = itr(visit);
    600         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralPrivate(t,visit);}
    601     }
    602
    603     public void visitLiteralProtected(GroovySourceAST t, int visit) {
    604         Iterator itr = itr(visit);
    605         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralProtected(t,visit);}
    606     }
    607
    608     public void visitLiteralPublic(GroovySourceAST t, int visit) {
    609         Iterator itr = itr(visit);
    610         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralPublic(t,visit);}
    611     }
    612
    613     public void visitLiteralReturn(GroovySourceAST t, int visit) {
    614         Iterator itr = itr(visit);
    615         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralReturn(t,visit);}
    616     }
    617
    618     public void visitLiteralShort(GroovySourceAST t, int visit) {
    619         Iterator itr = itr(visit);
    620         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralShort(t,visit);}
    621     }
    622
    623     public void visitLiteralStatic(GroovySourceAST t, int visit) {
    624         Iterator itr = itr(visit);
    625         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralStatic(t,visit);}
    626     }
    627
    628     public void visitLiteralSuper(GroovySourceAST t, int visit) {
    629         Iterator itr = itr(visit);
    630         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralSuper(t,visit);}
    631     }
    632
    633     public void visitLiteralSwitch(GroovySourceAST t, int visit) {
    634         Iterator itr = itr(visit);
    635         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralSwitch(t,visit);}
    636     }
    637
    638     public void visitLiteralSynchronized(GroovySourceAST t, int visit) {
    639         Iterator itr = itr(visit);
    640         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralSynchronized(t,visit);}
    641     }
    642
    643     public void visitLiteralThis(GroovySourceAST t, int visit) {
    644         Iterator itr = itr(visit);
    645         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralThis(t,visit);}
    646     }
    647
    648     public void visitLiteralThreadsafe(GroovySourceAST t, int visit) {
    649         Iterator itr = itr(visit);
    650         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralThreadsafe(t,visit);}
    651     }
    652
    653     public void visitLiteralThrow(GroovySourceAST t, int visit) {
    654         Iterator itr = itr(visit);
    655         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralThrow(t,visit);}
    656     }
    657
    658     public void visitLiteralThrows(GroovySourceAST t, int visit) {
    659         Iterator itr = itr(visit);
    660         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralThrows(t,visit);}
    661     }
    662
    663     public void visitLiteralTransient(GroovySourceAST t, int visit) {
    664         Iterator itr = itr(visit);
    665         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralTransient(t,visit);}
    666     }
    667
    668     public void visitLiteralTrue(GroovySourceAST t, int visit) {
    669         Iterator itr = itr(visit);
    670         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralTrue(t,visit);}
    671     }
    672
    673     public void visitLiteralTry(GroovySourceAST t, int visit) {
    674         Iterator itr = itr(visit);
    675         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralTry(t,visit);}
    676     }
    677
    678     public void visitLiteralVoid(GroovySourceAST t, int visit) {
    679         Iterator itr = itr(visit);
    680         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralVoid(t,visit);}
    681     }
    682
    683     public void visitLiteralVolatile(GroovySourceAST t, int visit) {
    684         Iterator itr = itr(visit);
    685         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralVolatile(t,visit);}
    686     }
    687
    688     public void visitLiteralWhile(GroovySourceAST t, int visit) {
    689         Iterator itr = itr(visit);
    690         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralWhile(t,visit);}
    691     }
    692
    693     public void visitLiteralWith(GroovySourceAST t, int visit) {
    694         Iterator itr = itr(visit);
    695         while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralWith(t,visit);}
    696     }
    697
    698     public void visitLnot(GroovySourceAST t, int visit) {
    699         Iterator itr = itr(visit);
    700         while (itr.hasNext()) {((Visitor)itr.next()).visitLnot(t,visit);}
    701     }
    702
    703     public void visitLor(GroovySourceAST t, int visit) {
    704         Iterator itr = itr(visit);
    705         while (itr.hasNext()) {((Visitor)itr.next()).visitLor(t,visit);}
    706     }
    707
    708     public void visitLparen(GroovySourceAST t, int visit) {
    709         Iterator itr = itr(visit);
    710         while (itr.hasNext()) {((Visitor)itr.next()).visitLparen(t,visit);}
    711     }
    712
    713     public void visitLt(GroovySourceAST t, int visit) {
    714         Iterator itr = itr(visit);
    715         while (itr.hasNext()) {((Visitor)itr.next()).visitLt(t,visit);}
    716     }
    717
    718     public void visitMapConstructor(GroovySourceAST t, int visit) {
    719         Iterator itr = itr(visit);
    720         while (itr.hasNext()) {((Visitor)itr.next()).visitMapConstructor(t,visit);}
    721     }
    722
    723     public void visitMemberPointer(GroovySourceAST t, int visit) {
    724         Iterator itr = itr(visit);
    725         while (itr.hasNext()) {((Visitor)itr.next()).visitMemberPointer(t,visit);}
    726     }
    727
    728     public void visitMethodCall(GroovySourceAST t, int visit) {
    729         Iterator itr = itr(visit);
    730         while (itr.hasNext()) {((Visitor)itr.next()).visitMethodCall(t,visit);}
    731     }
    732
    733     public void visitMethodDef(GroovySourceAST t, int visit) {
    734         Iterator itr = itr(visit);
    735         while (itr.hasNext()) {((Visitor)itr.next()).visitMethodDef(t,visit);}
    736     }
    737
    738     public void visitMinus(GroovySourceAST t, int visit) {
    739         Iterator itr = itr(visit);
    740         while (itr.hasNext()) {((Visitor)itr.next()).visitMinus(t,visit);}
    741     }
    742
    743     public void visitMinusAssign(GroovySourceAST t, int visit) {
    744         Iterator itr = itr(visit);
    745         while (itr.hasNext()) {((Visitor)itr.next()).visitMinusAssign(t,visit);}
    746     }
    747
    748     public void visitMlComment(GroovySourceAST t, int visit) {
    749         Iterator itr = itr(visit);
    750         while (itr.hasNext()) {((Visitor)itr.next()).visitMlComment(t,visit);}
    751     }
    752
    753     public void visitMod(GroovySourceAST t, int visit) {
    754         Iterator itr = itr(visit);
    755         while (itr.hasNext()) {((Visitor)itr.next()).visitMod(t,visit);}
    756     }
    757
    758     public void visitModifiers(GroovySourceAST t, int visit) {
    759         Iterator itr = itr(visit);
    760         while (itr.hasNext()) {((Visitor)itr.next()).visitModifiers(t,visit);}
    761     }
    762
    763     public void visitModAssign(GroovySourceAST t, int visit) {
    764         Iterator itr = itr(visit);
    765         while (itr.hasNext()) {((Visitor)itr.next()).visitModAssign(t,visit);}
    766     }
    767
    768     public void visitNls(GroovySourceAST t, int visit) {
    769         Iterator itr = itr(visit);
    770         while (itr.hasNext()) {((Visitor)itr.next()).visitNls(t,visit);}
    771     }
    772
    773     public void visitNotEqual(GroovySourceAST t, int visit) {
    774         Iterator itr = itr(visit);
    775         while (itr.hasNext()) {((Visitor)itr.next()).visitNotEqual(t,visit);}
    776     }
    777
    778     public void visitNullTreeLookahead(GroovySourceAST t, int visit) {
    779         Iterator itr = itr(visit);
    780         while (itr.hasNext()) {((Visitor)itr.next()).visitNullTreeLookahead(t,visit);}
    781     }
    782
    783     public void visitNumBigDecimal(GroovySourceAST t, int visit) {
    784         Iterator itr = itr(visit);
    785         while (itr.hasNext()) {((Visitor)itr.next()).visitNumBigDecimal(t,visit);}
    786     }
    787
    788     public void visitNumBigInt(GroovySourceAST t, int visit) {
    789         Iterator itr = itr(visit);
    790         while (itr.hasNext()) {((Visitor)itr.next()).visitNumBigInt(t,visit);}
    791     }
    792
    793     public void visitNumDouble(GroovySourceAST t, int visit) {
    794         Iterator itr = itr(visit);
    795         while (itr.hasNext()) {((Visitor)itr.next()).visitNumDouble(t,visit);}
    796     }
    797
    798     public void visitNumFloat(GroovySourceAST t, int visit) {
    799         Iterator itr = itr(visit);
    800         while (itr.hasNext()) {((Visitor)itr.next()).visitNumFloat(t,visit);}
    801     }
    802
    803     public void visitNumInt(GroovySourceAST t, int visit) {
    804         Iterator itr = itr(visit);
    805         while (itr.hasNext()) {((Visitor)itr.next()).visitNumInt(t,visit);}
    806     }
    807
    808     public void visitNumLong(GroovySourceAST t, int visit) {
    809         Iterator itr = itr(visit);
    810         while (itr.hasNext()) {((Visitor)itr.next()).visitNumLong(t,visit);}
    811     }
    812
    813     public void visitObjblock(GroovySourceAST t, int visit) {
    814         Iterator itr = itr(visit);
    815         while (itr.hasNext()) {((Visitor)itr.next()).visitObjblock(t,visit);}
    816     }
    817
    818     public void visitOneNl(GroovySourceAST t, int visit) {
    819         Iterator itr = itr(visit);
    820         while (itr.hasNext()) {((Visitor)itr.next()).visitOneNl(t,visit);}
    821     }
    822
    823     public void visitOptionalDot(GroovySourceAST t, int visit) {
    824         Iterator itr = itr(visit);
    825         while (itr.hasNext()) {((Visitor)itr.next()).visitOptionalDot(t,visit);}
    826     }
    827
    828     public void visitPackageDef(GroovySourceAST t, int visit) {
    829         Iterator itr = itr(visit);
    830         while (itr.hasNext()) {((Visitor)itr.next()).visitPackageDef(t,visit);}
    831     }
    832
    833     public void visitParameters(GroovySourceAST t, int visit) {
    834         Iterator itr = itr(visit);
    835         while (itr.hasNext()) {((Visitor)itr.next()).visitParameters(t,visit);}
    836     }
    837
    838     public void visitParameterDef(GroovySourceAST t, int visit) {
    839         Iterator itr = itr(visit);
    840         while (itr.hasNext()) {((Visitor)itr.next()).visitParameterDef(t,visit);}
    841     }
    842
    843     public void visitPlus(GroovySourceAST t, int visit) {
    844         Iterator itr = itr(visit);
    845         while (itr.hasNext()) {((Visitor)itr.next()).visitPlus(t,visit);}
    846     }
    847
    848     public void visitPlusAssign(GroovySourceAST t, int visit) {
    849         Iterator itr = itr(visit);
    850         while (itr.hasNext()) {((Visitor)itr.next()).visitPlusAssign(t,visit);}
    851     }
    852
    853     public void visitPostDec(GroovySourceAST t, int visit) {
    854         Iterator itr = itr(visit);
    855         while (itr.hasNext()) {((Visitor)itr.next()).visitPostDec(t,visit);}
    856     }
    857
    858     public void visitPostInc(GroovySourceAST t, int visit) {
    859         Iterator itr = itr(visit);
    860         while (itr.hasNext()) {((Visitor)itr.next()).visitPostInc(t,visit);}
    861     }
    862
    863     public void visitQuestion(GroovySourceAST t, int visit) {
    864         Iterator itr = itr(visit);
    865         while (itr.hasNext()) {((Visitor)itr.next()).visitQuestion(t,visit);}
    866     }
    867
    868     public void visitRangeExclusive(GroovySourceAST t, int visit) {
    869         Iterator itr = itr(visit);
    870         while (itr.hasNext()) {((Visitor)itr.next()).visitRangeExclusive(t,visit);}
    871     }
    872
    873     public void visitRangeInclusive(GroovySourceAST t, int visit) {
    874         Iterator itr = itr(visit);
    875         while (itr.hasNext()) {((Visitor)itr.next()).visitRangeInclusive(t,visit);}
    876     }
    877
    878     public void visitRbrack(GroovySourceAST t, int visit) {
    879         Iterator itr = itr(visit);
    880         while (itr.hasNext()) {((Visitor)itr.next()).visitRbrack(t,visit);}
    881     }
    882
    883     public void visitRcurly(GroovySourceAST t, int visit) {
    884         Iterator itr = itr(visit);
    885         while (itr.hasNext()) {((Visitor)itr.next()).visitRcurly(t,visit);}
    886     }
    887
    888     public void visitRegexpCtorEnd(GroovySourceAST t, int visit) {
    889         Iterator itr = itr(visit);
    890         while (itr.hasNext()) {((Visitor)itr.next()).visitRegexpCtorEnd(t,visit);}
    891     }
    892
    893     public void visitRegexpLiteral(GroovySourceAST t, int visit) {
    894         Iterator itr = itr(visit);
    895         while (itr.hasNext()) {((Visitor)itr.next()).visitRegexpLiteral(t,visit);}
    896     }
    897
    898     public void visitRegexpSymbol(GroovySourceAST t, int visit) {
    899         Iterator itr = itr(visit);
    900         while (itr.hasNext()) {((Visitor)itr.next()).visitRegexpSymbol(t,visit);}
    901     }
    902
    903     public void visitRegexFind(GroovySourceAST t, int visit) {
    904         Iterator itr = itr(visit);
    905         while (itr.hasNext()) {((Visitor)itr.next()).visitRegexFind(t,visit);}
    906     }
    907
    908     public void visitRegexMatch(GroovySourceAST t, int visit) {
    909         Iterator itr = itr(visit);
    910         while (itr.hasNext()) {((Visitor)itr.next()).visitRegexMatch(t,visit);}
    911     }
    912
    913     public void visitRparen(GroovySourceAST t, int visit) {
    914         Iterator itr = itr(visit);
    915         while (itr.hasNext()) {((Visitor)itr.next()).visitRparen(t,visit);}
    916     }
    917
    918     public void visitScopeEscape(GroovySourceAST t, int visit) {
    919         Iterator itr = itr(visit);
    920         while (itr.hasNext()) {((Visitor)itr.next()).visitScopeEscape(t,visit);}
    921     }
    922
    923     public void visitSelectSlot(GroovySourceAST t, int visit) {
    924         Iterator itr = itr(visit);
    925         while (itr.hasNext()) {((Visitor)itr.next()).visitSelectSlot(t,visit);}
    926     }
    927
    928     public void visitSemi(GroovySourceAST t, int visit) {
    929         Iterator itr = itr(visit);
    930         while (itr.hasNext()) {((Visitor)itr.next()).visitSemi(t,visit);}
    931     }
    932
    933     public void visitShComment(GroovySourceAST t, int visit) {
    934         Iterator itr = itr(visit);
    935         while (itr.hasNext()) {((Visitor)itr.next()).visitShComment(t,visit);}
    936     }
    937
    938     public void visitSl(GroovySourceAST t, int visit) {
    939         Iterator itr = itr(visit);
    940         while (itr.hasNext()) {((Visitor)itr.next()).visitSl(t,visit);}
    941     }
    942
    943     public void visitSlist(GroovySourceAST t, int visit) {
    944         Iterator itr = itr(visit);
    945         while (itr.hasNext()) {((Visitor)itr.next()).visitSlist(t,visit);}
    946     }
    947
    948     public void visitSlAssign(GroovySourceAST t, int visit) {
    949         Iterator itr = itr(visit);
    950         while (itr.hasNext()) {((Visitor)itr.next()).visitSlAssign(t,visit);}
    951     }
    952
    953     public void visitSlComment(GroovySourceAST t, int visit) {
    954         Iterator itr = itr(visit);
    955         while (itr.hasNext()) {((Visitor)itr.next()).visitSlComment(t,visit);}
    956     }
    957
    958     public void visitSpreadArg(GroovySourceAST t, int visit) {
    959         Iterator itr = itr(visit);
    960         while (itr.hasNext()) {((Visitor)itr.next()).visitSpreadArg(t,visit);}
    961     }
    962
    963     public void visitSpreadDot(GroovySourceAST t, int visit) {
    964         Iterator itr = itr(visit);
    965         while (itr.hasNext()) {((Visitor)itr.next()).visitSpreadDot(t,visit);}
    966     }
    967
    968     public void visitSpreadMapArg(GroovySourceAST t, int visit) {
    969         Iterator itr = itr(visit);
    970         while (itr.hasNext()) {((Visitor)itr.next()).visitSpreadMapArg(t,visit);}
    971     }
    972
    973     public void visitSr(GroovySourceAST t, int visit) {
    974         Iterator itr = itr(visit);
    975         while (itr.hasNext()) {((Visitor)itr.next()).visitSr(t,visit);}
    976     }
    977
    978     public void visitSrAssign(GroovySourceAST t, int visit) {
    979         Iterator itr = itr(visit);
    980         while (itr.hasNext()) {((Visitor)itr.next()).visitSrAssign(t,visit);}
    981     }
    982
    983     public void visitStar(GroovySourceAST t, int visit) {
    984         Iterator itr = itr(visit);
    985         while (itr.hasNext()) {((Visitor)itr.next()).visitStar(t,visit);}
    986     }
    987
    988     public void visitStarAssign(GroovySourceAST t, int visit) {
    989         Iterator itr = itr(visit);
    990         while (itr.hasNext()) {((Visitor)itr.next()).visitStarAssign(t,visit);}
    991     }
    992
    993     public void visitStarStar(GroovySourceAST t, int visit) {
    994         Iterator itr = itr(visit);
    995         while (itr.hasNext()) {((Visitor)itr.next()).visitStarStar(t,visit);}
    996     }
    997
    998     public void visitStarStarAssign(GroovySourceAST t, int visit) {
    999         Iterator itr = itr(visit);
    1000         while (itr.hasNext()) {((Visitor)itr.next()).visitStarStarAssign(t,visit);}
    1001     }
    1002
    1003     public void visitStaticImport(GroovySourceAST t, int visit) {
    1004         Iterator itr = itr(visit);
    1005         while (itr.hasNext()) {((Visitor)itr.next()).visitStaticImport(t,visit);}
    1006     }
    1007
    1008     public void visitStaticInit(GroovySourceAST t, int visit) {
    1009         Iterator itr = itr(visit);
    1010         while (itr.hasNext()) {((Visitor)itr.next()).visitStaticInit(t,visit);}
    1011     }
    1012
    1013     public void visitStrictfp(GroovySourceAST t, int visit) {
    1014         Iterator itr = itr(visit);
    1015         while (itr.hasNext()) {((Visitor)itr.next()).visitStrictfp(t,visit);}
    1016     }
    1017
    1018     public void visitStringCh(GroovySourceAST t, int visit) {
    1019         Iterator itr = itr(visit);
    1020         while (itr.hasNext()) {((Visitor)itr.next()).visitStringCh(t,visit);}
    1021     }
    1022
    1023     public void visitStringConstructor(GroovySourceAST t, int visit) {
    1024         Iterator itr = itr(visit);
    1025         while (itr.hasNext()) {((Visitor)itr.next()).visitStringConstructor(t,visit);}
    1026     }
    1027
    1028     public void visitStringCtorEnd(GroovySourceAST t, int visit) {
    1029         Iterator itr = itr(visit);
    1030         while (itr.hasNext()) {((Visitor)itr.next()).visitStringCtorEnd(t,visit);}
    1031     }
    1032
    1033     public void visitStringCtorMiddle(GroovySourceAST t, int visit) {
    1034         Iterator itr = itr(visit);
    1035         while (itr.hasNext()) {((Visitor)itr.next()).visitStringCtorMiddle(t,visit);}
    1036     }
    1037
    1038     public void visitStringCtorStart(GroovySourceAST t, int visit) {
    1039         Iterator itr = itr(visit);
    1040         while (itr.hasNext()) {((Visitor)itr.next()).visitStringCtorStart(t,visit);}
    1041     }
    1042
    1043     public void visitStringLiteral(GroovySourceAST t, int visit) {
    1044         Iterator itr = itr(visit);
    1045         while (itr.hasNext()) {((Visitor)itr.next()).visitStringLiteral(t,visit);}
    1046     }
    1047
    1048     public void visitStringNl(GroovySourceAST t, int visit) {
    1049         Iterator itr = itr(visit);
    1050         while (itr.hasNext()) {((Visitor)itr.next()).visitStringNl(t,visit);}
    1051     }
    1052
    1053     public void visitSuperCtorCall(GroovySourceAST t, int visit) {
    1054         Iterator itr = itr(visit);
    1055         while (itr.hasNext()) {((Visitor)itr.next()).visitSuperCtorCall(t,visit);}
    1056     }
    1057
    1058     public void visitTripleDot(GroovySourceAST t, int visit) {
    1059         Iterator itr = itr(visit);
    1060         while (itr.hasNext()) {((Visitor)itr.next()).visitTripleDot(t,visit);}
    1061     }
    1062
    1063     public void visitType(GroovySourceAST t, int visit) {
    1064         Iterator itr = itr(visit);
    1065         while (itr.hasNext()) {((Visitor)itr.next()).visitType(t,visit);}
    1066     }
    1067
    1068     public void visitTypecast(GroovySourceAST t, int visit) {
    1069         Iterator itr = itr(visit);
    1070         while (itr.hasNext()) {((Visitor)itr.next()).visitTypecast(t,visit);}
    1071     }
    1072
    1073     public void visitTypeArgument(GroovySourceAST t, int visit) {
    1074         Iterator itr = itr(visit);
    1075         while (itr.hasNext()) {((Visitor)itr.next()).visitTypeArgument(t,visit);}
    1076     }
    1077
    1078     public void visitTypeArguments(GroovySourceAST t, int visit) {
    1079         Iterator itr = itr(visit);
    1080         while (itr.hasNext()) {((Visitor)itr.next()).visitTypeArguments(t,visit);}
    1081     }
    1082
    1083     public void visitTypeLowerBounds(GroovySourceAST t, int visit) {
    1084         Iterator itr = itr(visit);
    1085         while (itr.hasNext()) {((Visitor)itr.next()).visitTypeLowerBounds(t,visit);}
    1086     }
    1087
    1088     public void visitTypeParameter(GroovySourceAST t, int visit) {
    1089         Iterator itr = itr(visit);
    1090         while (itr.hasNext()) {((Visitor)itr.next()).visitTypeParameter(t,visit);}
    1091     }
    1092
    1093     public void visitTypeParameters(GroovySourceAST t, int visit) {
    1094         Iterator itr = itr(visit);
    1095         while (itr.hasNext()) {((Visitor)itr.next()).visitTypeParameters(t,visit);}
    1096     }
    1097
    1098     public void visitTypeUpperBounds(GroovySourceAST t, int visit) {
    1099         Iterator itr = itr(visit);
    1100         while (itr.hasNext()) {((Visitor)itr.next()).visitTypeUpperBounds(t,visit);}
    1101     }
    1102
    1103     public void visitUnaryMinus(GroovySourceAST t, int visit) {
    1104         Iterator itr = itr(visit);
    1105         while (itr.hasNext()) {((Visitor)itr.next()).visitUnaryMinus(t,visit);}
    1106     }
    1107
    1108     public void visitUnaryPlus(GroovySourceAST t, int visit) {
    1109         Iterator itr = itr(visit);
    1110         while (itr.hasNext()) {((Visitor)itr.next()).visitUnaryPlus(t,visit);}
    1111     }
    1112
    1113     public void visitUnusedConst(GroovySourceAST t, int visit) {
    1114         Iterator itr = itr(visit);
    1115         while (itr.hasNext()) {((Visitor)itr.next()).visitUnusedConst(t,visit);}
    1116     }
    1117
    1118     public void visitUnusedDo(GroovySourceAST t, int visit) {
    1119         Iterator itr = itr(visit);
    1120         while (itr.hasNext()) {((Visitor)itr.next()).visitUnusedDo(t,visit);}
    1121     }
    1122
    1123     public void visitUnusedGoto(GroovySourceAST t, int visit) {
    1124         Iterator itr = itr(visit);
    1125         while (itr.hasNext()) {((Visitor)itr.next()).visitUnusedGoto(t,visit);}
    1126     }
    1127
    1128     public void visitVariableDef(GroovySourceAST t, int visit) {
    1129         Iterator itr = itr(visit);
    1130         while (itr.hasNext()) {((Visitor)itr.next()).visitVariableDef(t,visit);}
    1131     }
    1132
    1133     public void visitVariableParameterDef(GroovySourceAST t, int visit) {
    1134         Iterator itr = itr(visit);
    1135         while (itr.hasNext()) {((Visitor)itr.next()).visitVariableParameterDef(t,visit);}
    1136     }
    1137
    1138     public void visitVocab(GroovySourceAST t, int visit) {
    1139         Iterator itr = itr(visit);
    1140         while (itr.hasNext()) {((Visitor)itr.next()).visitVocab(t,visit);}
    1141     }
    1142
    1143     public void visitWildcardType(GroovySourceAST t, int visit) {
    1144         Iterator itr = itr(visit);
    1145         while (itr.hasNext()) {((Visitor)itr.next()).visitWildcardType(t,visit);}
    1146     }
    1147
    1148     public void visitWs(GroovySourceAST t, int visit) {
    1149         Iterator itr = itr(visit);
    1150         while (itr.hasNext()) {((Visitor)itr.next()).visitWs(t,visit);}
    1151     }
    1152
    1153
    1154
    1155
    1156
    1157     public void visitDefault(GroovySourceAST t, int visit) {
    1158         Iterator itr = itr(visit);
    1159         while (itr.hasNext()) {((Visitor)itr.next()).visitDefault(t,visit);}
    1160     }
    1161
    1162     public void tearDown() {
    1163         Iterator itr = backToFrontVisitors.iterator();
    1164         while (itr.hasNext()) {((Visitor)itr.next()).tearDown();}
    1165     }
    1166
    1167     public void push(GroovySourceAST t) {
    1168         Iterator itr = visitors.iterator();
    1169         while (itr.hasNext()) {((Visitor)itr.next()).push(t);}
    1170     }
    1171     public GroovySourceAST pop() {
    1172         GroovySourceAST lastNodePopped = null;
    1173         Iterator itr = backToFrontVisitors.iterator();
    1174         while (itr.hasNext()) {lastNodePopped = (GroovySourceAST) ((Visitor)itr.next()).pop();}
    1175         return lastNodePopped;
    1176     }
    1177
    1178 }