Source Code Cross Referenced for DepthFirstVisitor.java in  » Parser » Rats-Parser-Generators » xtc » lang » javacc » visitor » Java Source Code / Java DocumentationJava Source Code and Java Documentation

0001:        //
0002:        // Generated by JTB 1.2.2
0003:        //
0004:
0005:        package xtc.lang.javacc.visitor;
0006:
0007:        import xtc.lang.javacc.syntaxtree.*;
0008:        import java.util.*;
0009:
0010:        /**
0011:         * Provides default methods which visit each node in the tree in depth-first
0012:         * order.  Your visitors may extend this class.
0013:         */
0014:        public class DepthFirstVisitor implements  Visitor {
0015:            //
0016:            // Auto class visitors--probably don't need to be overridden.
0017:            //
0018:            public void visit(NodeList n) {
0019:                for (Enumeration e = n.elements(); e.hasMoreElements();)
0020:                    ((Node) e.nextElement()).accept(this );
0021:            }
0022:
0023:            public void visit(NodeListOptional n) {
0024:                if (n.present())
0025:                    for (Enumeration e = n.elements(); e.hasMoreElements();)
0026:                        ((Node) e.nextElement()).accept(this );
0027:            }
0028:
0029:            public void visit(NodeOptional n) {
0030:                if (n.present())
0031:                    n.node.accept(this );
0032:            }
0033:
0034:            public void visit(NodeSequence n) {
0035:                for (Enumeration e = n.elements(); e.hasMoreElements();)
0036:                    ((Node) e.nextElement()).accept(this );
0037:            }
0038:
0039:            public void visit(NodeToken n) {
0040:            }
0041:
0042:            //
0043:            // User-generated visitor methods below
0044:            //
0045:
0046:            /**
0047:             * Visit the specified node.
0048:             * <pre>
0049:             * f0 -> [ PackageDeclaration() ]
0050:             * f1 -> ( ImportDeclaration() )*
0051:             * f2 -> ( TypeDeclaration() )*
0052:             * f3 -> &lt;EOF&gt;
0053:             * </pre>
0054:             */
0055:            public void visit(CompilationUnit n) {
0056:                n.f0.accept(this );
0057:                n.f1.accept(this );
0058:                n.f2.accept(this );
0059:                n.f3.accept(this );
0060:            }
0061:
0062:            /**
0063:             * Visit the specified node.
0064:             * <pre>
0065:             * f0 -> "package"
0066:             * f1 -> Name()
0067:             * f2 -> ";"
0068:             * </pre>
0069:             */
0070:            public void visit(PackageDeclaration n) {
0071:                n.f0.accept(this );
0072:                n.f1.accept(this );
0073:                n.f2.accept(this );
0074:            }
0075:
0076:            /**
0077:             * Visit the specified node.
0078:             * <pre>
0079:             * f0 -> "import"
0080:             * f1 -> Name()
0081:             * f2 -> [ "." "*" ]
0082:             * f3 -> ";"
0083:             * </pre>
0084:             */
0085:            public void visit(ImportDeclaration n) {
0086:                n.f0.accept(this );
0087:                n.f1.accept(this );
0088:                n.f2.accept(this );
0089:                n.f3.accept(this );
0090:            }
0091:
0092:            /**
0093:             * Visit the specified node.
0094:             * <pre>
0095:             * f0 -> ClassDeclaration()
0096:             *       | InterfaceDeclaration()
0097:             *       | ";"
0098:             * </pre>
0099:             */
0100:            public void visit(TypeDeclaration n) {
0101:                n.f0.accept(this );
0102:            }
0103:
0104:            /**
0105:             * Visit the specified node.
0106:             * <pre>
0107:             * f0 -> ( "abstract" | "final" | "public" | "strictfp" )*
0108:             * f1 -> UnmodifiedClassDeclaration()
0109:             * </pre>
0110:             */
0111:            public void visit(ClassDeclaration n) {
0112:                n.f0.accept(this );
0113:                n.f1.accept(this );
0114:            }
0115:
0116:            /**
0117:             * Visit the specified node.
0118:             * <pre>
0119:             * f0 -> "class"
0120:             * f1 -> &lt;IDENTIFIER&gt;
0121:             * f2 -> [ "extends" Name() ]
0122:             * f3 -> [ "implements" NameList() ]
0123:             * f4 -> ClassBody()
0124:             * </pre>
0125:             */
0126:            public void visit(UnmodifiedClassDeclaration n) {
0127:                n.f0.accept(this );
0128:                n.f1.accept(this );
0129:                n.f2.accept(this );
0130:                n.f3.accept(this );
0131:                n.f4.accept(this );
0132:            }
0133:
0134:            /**
0135:             * Visit the specified node.
0136:             * <pre>
0137:             * f0 -> "{"
0138:             * f1 -> ( ClassBodyDeclaration() )*
0139:             * f2 -> "}"
0140:             * </pre>
0141:             */
0142:            public void visit(ClassBody n) {
0143:                n.f0.accept(this );
0144:                n.f1.accept(this );
0145:                n.f2.accept(this );
0146:            }
0147:
0148:            /**
0149:             * Visit the specified node.
0150:             * <pre>
0151:             * f0 -> ( "static" | "abstract" | "final" | "public" | "protected" | "private" | "strictfp" )*
0152:             * f1 -> UnmodifiedClassDeclaration()
0153:             * </pre>
0154:             */
0155:            public void visit(NestedClassDeclaration n) {
0156:                n.f0.accept(this );
0157:                n.f1.accept(this );
0158:            }
0159:
0160:            /**
0161:             * Visit the specified node.
0162:             * <pre>
0163:             * f0 -> Initializer()
0164:             *       | NestedClassDeclaration()
0165:             *       | NestedInterfaceDeclaration()
0166:             *       | ConstructorDeclaration()
0167:             *       | MethodDeclaration()
0168:             *       | FieldDeclaration()
0169:             *       | ";"
0170:             * </pre>
0171:             */
0172:            public void visit(ClassBodyDeclaration n) {
0173:                n.f0.accept(this );
0174:            }
0175:
0176:            /**
0177:             * Visit the specified node.
0178:             * <pre>
0179:             * f0 -> ( "public" | "protected" | "private" | "static" | "abstract" | "final" | "native" | "synchronized" | "strictfp" )*
0180:             * f1 -> ResultType()
0181:             * f2 -> &lt;IDENTIFIER&gt;
0182:             * f3 -> "("
0183:             * </pre>
0184:             */
0185:            public void visit(MethodDeclarationLookahead n) {
0186:                n.f0.accept(this );
0187:                n.f1.accept(this );
0188:                n.f2.accept(this );
0189:                n.f3.accept(this );
0190:            }
0191:
0192:            /**
0193:             * Visit the specified node.
0194:             * <pre>
0195:             * f0 -> ( "abstract" | "public" | "strictfp" )*
0196:             * f1 -> UnmodifiedInterfaceDeclaration()
0197:             * </pre>
0198:             */
0199:            public void visit(InterfaceDeclaration n) {
0200:                n.f0.accept(this );
0201:                n.f1.accept(this );
0202:            }
0203:
0204:            /**
0205:             * Visit the specified node.
0206:             * <pre>
0207:             * f0 -> ( "static" | "abstract" | "final" | "public" | "protected" | "private" | "strictfp" )*
0208:             * f1 -> UnmodifiedInterfaceDeclaration()
0209:             * </pre>
0210:             */
0211:            public void visit(NestedInterfaceDeclaration n) {
0212:                n.f0.accept(this );
0213:                n.f1.accept(this );
0214:            }
0215:
0216:            /**
0217:             * Visit the specified node.
0218:             * <pre>
0219:             * f0 -> "interface"
0220:             * f1 -> &lt;IDENTIFIER&gt;
0221:             * f2 -> [ "extends" NameList() ]
0222:             * f3 -> "{"
0223:             * f4 -> ( InterfaceMemberDeclaration() )*
0224:             * f5 -> "}"
0225:             * </pre>
0226:             */
0227:            public void visit(UnmodifiedInterfaceDeclaration n) {
0228:                n.f0.accept(this );
0229:                n.f1.accept(this );
0230:                n.f2.accept(this );
0231:                n.f3.accept(this );
0232:                n.f4.accept(this );
0233:                n.f5.accept(this );
0234:            }
0235:
0236:            /**
0237:             * Visit the specified node.
0238:             * <pre>
0239:             * f0 -> NestedClassDeclaration()
0240:             *       | NestedInterfaceDeclaration()
0241:             *       | MethodDeclaration()
0242:             *       | FieldDeclaration()
0243:             *       | ";"
0244:             * </pre>
0245:             */
0246:            public void visit(InterfaceMemberDeclaration n) {
0247:                n.f0.accept(this );
0248:            }
0249:
0250:            /**
0251:             * Visit the specified node.
0252:             * <pre>
0253:             * f0 -> ( "public" | "protected" | "private" | "static" | "final" | "transient" | "volatile" )*
0254:             * f1 -> Type()
0255:             * f2 -> VariableDeclarator()
0256:             * f3 -> ( "," VariableDeclarator() )*
0257:             * f4 -> ";"
0258:             * </pre>
0259:             */
0260:            public void visit(FieldDeclaration n) {
0261:                n.f0.accept(this );
0262:                n.f1.accept(this );
0263:                n.f2.accept(this );
0264:                n.f3.accept(this );
0265:                n.f4.accept(this );
0266:            }
0267:
0268:            /**
0269:             * Visit the specified node.
0270:             * <pre>
0271:             * f0 -> VariableDeclaratorId()
0272:             * f1 -> [ "=" VariableInitializer() ]
0273:             * </pre>
0274:             */
0275:            public void visit(VariableDeclarator n) {
0276:                n.f0.accept(this );
0277:                n.f1.accept(this );
0278:            }
0279:
0280:            /**
0281:             * Visit the specified node.
0282:             * <pre>
0283:             * f0 -> &lt;IDENTIFIER&gt;
0284:             * f1 -> ( "[" "]" )*
0285:             * </pre>
0286:             */
0287:            public void visit(VariableDeclaratorId n) {
0288:                n.f0.accept(this );
0289:                n.f1.accept(this );
0290:            }
0291:
0292:            /**
0293:             * Visit the specified node.
0294:             * <pre>
0295:             * f0 -> ArrayInitializer()
0296:             *       | Expression()
0297:             * </pre>
0298:             */
0299:            public void visit(VariableInitializer n) {
0300:                n.f0.accept(this );
0301:            }
0302:
0303:            /**
0304:             * Visit the specified node.
0305:             * <pre>
0306:             * f0 -> "{"
0307:             * f1 -> [ VariableInitializer() ( "," VariableInitializer() )* ]
0308:             * f2 -> [ "," ]
0309:             * f3 -> "}"
0310:             * </pre>
0311:             */
0312:            public void visit(ArrayInitializer n) {
0313:                n.f0.accept(this );
0314:                n.f1.accept(this );
0315:                n.f2.accept(this );
0316:                n.f3.accept(this );
0317:            }
0318:
0319:            /**
0320:             * Visit the specified node.
0321:             * <pre>
0322:             * f0 -> ( "public" | "protected" | "private" | "static" | "abstract" | "final" | "native" | "synchronized" | "strictfp" )*
0323:             * f1 -> ResultType()
0324:             * f2 -> MethodDeclarator()
0325:             * f3 -> [ "throws" NameList() ]
0326:             * f4 -> ( Block() | ";" )
0327:             * </pre>
0328:             */
0329:            public void visit(MethodDeclaration n) {
0330:                n.f0.accept(this );
0331:                n.f1.accept(this );
0332:                n.f2.accept(this );
0333:                n.f3.accept(this );
0334:                n.f4.accept(this );
0335:            }
0336:
0337:            /**
0338:             * Visit the specified node.
0339:             * <pre>
0340:             * f0 -> &lt;IDENTIFIER&gt;
0341:             * f1 -> FormalParameters()
0342:             * f2 -> ( "[" "]" )*
0343:             * </pre>
0344:             */
0345:            public void visit(MethodDeclarator n) {
0346:                n.f0.accept(this );
0347:                n.f1.accept(this );
0348:                n.f2.accept(this );
0349:            }
0350:
0351:            /**
0352:             * Visit the specified node.
0353:             * <pre>
0354:             * f0 -> "("
0355:             * f1 -> [ FormalParameter() ( "," FormalParameter() )* ]
0356:             * f2 -> ")"
0357:             * </pre>
0358:             */
0359:            public void visit(FormalParameters n) {
0360:                n.f0.accept(this );
0361:                n.f1.accept(this );
0362:                n.f2.accept(this );
0363:            }
0364:
0365:            /**
0366:             * Visit the specified node.
0367:             * <pre>
0368:             * f0 -> [ "final" ]
0369:             * f1 -> Type()
0370:             * f2 -> VariableDeclaratorId()
0371:             * </pre>
0372:             */
0373:            public void visit(FormalParameter n) {
0374:                n.f0.accept(this );
0375:                n.f1.accept(this );
0376:                n.f2.accept(this );
0377:            }
0378:
0379:            /**
0380:             * Visit the specified node.
0381:             * <pre>
0382:             * f0 -> [ "public" | "protected" | "private" ]
0383:             * f1 -> &lt;IDENTIFIER&gt;
0384:             * f2 -> FormalParameters()
0385:             * f3 -> [ "throws" NameList() ]
0386:             * f4 -> "{"
0387:             * f5 -> [ ExplicitConstructorInvocation() ]
0388:             * f6 -> ( BlockStatement() )*
0389:             * f7 -> "}"
0390:             * </pre>
0391:             */
0392:            public void visit(ConstructorDeclaration n) {
0393:                n.f0.accept(this );
0394:                n.f1.accept(this );
0395:                n.f2.accept(this );
0396:                n.f3.accept(this );
0397:                n.f4.accept(this );
0398:                n.f5.accept(this );
0399:                n.f6.accept(this );
0400:                n.f7.accept(this );
0401:            }
0402:
0403:            /**
0404:             * Visit the specified node.
0405:             * <pre>
0406:             * f0 -> "this" Arguments() ";"
0407:             *       | [ PrimaryExpression() "." ] "super" Arguments() ";"
0408:             * </pre>
0409:             */
0410:            public void visit(ExplicitConstructorInvocation n) {
0411:                n.f0.accept(this );
0412:            }
0413:
0414:            /**
0415:             * Visit the specified node.
0416:             * <pre>
0417:             * f0 -> [ "static" ]
0418:             * f1 -> Block()
0419:             * </pre>
0420:             */
0421:            public void visit(Initializer n) {
0422:                n.f0.accept(this );
0423:                n.f1.accept(this );
0424:            }
0425:
0426:            /**
0427:             * Visit the specified node.
0428:             * <pre>
0429:             * f0 -> ( PrimitiveType() | Name() )
0430:             * f1 -> ( "[" "]" )*
0431:             * </pre>
0432:             */
0433:            public void visit(Type n) {
0434:                n.f0.accept(this );
0435:                n.f1.accept(this );
0436:            }
0437:
0438:            /**
0439:             * Visit the specified node.
0440:             * <pre>
0441:             * f0 -> "boolean"
0442:             *       | "char"
0443:             *       | "byte"
0444:             *       | "short"
0445:             *       | "int"
0446:             *       | "long"
0447:             *       | "float"
0448:             *       | "double"
0449:             * </pre>
0450:             */
0451:            public void visit(PrimitiveType n) {
0452:                n.f0.accept(this );
0453:            }
0454:
0455:            /**
0456:             * Visit the specified node.
0457:             * <pre>
0458:             * f0 -> "void"
0459:             *       | Type()
0460:             * </pre>
0461:             */
0462:            public void visit(ResultType n) {
0463:                n.f0.accept(this );
0464:            }
0465:
0466:            /**
0467:             * Visit the specified node.
0468:             * <pre>
0469:             * f0 -> &lt;IDENTIFIER&gt;
0470:             * f1 -> ( "." &lt;IDENTIFIER&gt; )*
0471:             * </pre>
0472:             */
0473:            public void visit(Name n) {
0474:                n.f0.accept(this );
0475:                n.f1.accept(this );
0476:            }
0477:
0478:            /**
0479:             * Visit the specified node.
0480:             * <pre>
0481:             * f0 -> Name()
0482:             * f1 -> ( "," Name() )*
0483:             * </pre>
0484:             */
0485:            public void visit(NameList n) {
0486:                n.f0.accept(this );
0487:                n.f1.accept(this );
0488:            }
0489:
0490:            /**
0491:             * Visit the specified node.
0492:             * <pre>
0493:             * f0 -> ConditionalExpression()
0494:             * f1 -> [ AssignmentOperator() Expression() ]
0495:             * </pre>
0496:             */
0497:            public void visit(Expression n) {
0498:                n.f0.accept(this );
0499:                n.f1.accept(this );
0500:            }
0501:
0502:            /**
0503:             * Visit the specified node.
0504:             * <pre>
0505:             * f0 -> "="
0506:             *       | "*="
0507:             *       | "/="
0508:             *       | "%="
0509:             *       | "+="
0510:             *       | "-="
0511:             *       | "&lt;&lt;="
0512:             *       | "&gt;&gt;="
0513:             *       | "&gt;&gt;&gt;="
0514:             *       | "&="
0515:             *       | "^="
0516:             *       | "|="
0517:             * </pre>
0518:             */
0519:            public void visit(AssignmentOperator n) {
0520:                n.f0.accept(this );
0521:            }
0522:
0523:            /**
0524:             * Visit the specified node.
0525:             * <pre>
0526:             * f0 -> ConditionalOrExpression()
0527:             * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
0528:             * </pre>
0529:             */
0530:            public void visit(ConditionalExpression n) {
0531:                n.f0.accept(this );
0532:                n.f1.accept(this );
0533:            }
0534:
0535:            /**
0536:             * Visit the specified node.
0537:             * <pre>
0538:             * f0 -> ConditionalAndExpression()
0539:             * f1 -> ( "||" ConditionalAndExpression() )*
0540:             * </pre>
0541:             */
0542:            public void visit(ConditionalOrExpression n) {
0543:                n.f0.accept(this );
0544:                n.f1.accept(this );
0545:            }
0546:
0547:            /**
0548:             * Visit the specified node.
0549:             * <pre>
0550:             * f0 -> InclusiveOrExpression()
0551:             * f1 -> ( "&&" InclusiveOrExpression() )*
0552:             * </pre>
0553:             */
0554:            public void visit(ConditionalAndExpression n) {
0555:                n.f0.accept(this );
0556:                n.f1.accept(this );
0557:            }
0558:
0559:            /**
0560:             * Visit the specified node.
0561:             * <pre>
0562:             * f0 -> ExclusiveOrExpression()
0563:             * f1 -> ( "|" ExclusiveOrExpression() )*
0564:             * </pre>
0565:             */
0566:            public void visit(InclusiveOrExpression n) {
0567:                n.f0.accept(this );
0568:                n.f1.accept(this );
0569:            }
0570:
0571:            /**
0572:             * Visit the specified node.
0573:             * <pre>
0574:             * f0 -> AndExpression()
0575:             * f1 -> ( "^" AndExpression() )*
0576:             * </pre>
0577:             */
0578:            public void visit(ExclusiveOrExpression n) {
0579:                n.f0.accept(this );
0580:                n.f1.accept(this );
0581:            }
0582:
0583:            /**
0584:             * Visit the specified node.
0585:             * <pre>
0586:             * f0 -> EqualityExpression()
0587:             * f1 -> ( "&" EqualityExpression() )*
0588:             * </pre>
0589:             */
0590:            public void visit(AndExpression n) {
0591:                n.f0.accept(this );
0592:                n.f1.accept(this );
0593:            }
0594:
0595:            /**
0596:             * Visit the specified node.
0597:             * <pre>
0598:             * f0 -> InstanceOfExpression()
0599:             * f1 -> ( ( "==" | "!=" ) InstanceOfExpression() )*
0600:             * </pre>
0601:             */
0602:            public void visit(EqualityExpression n) {
0603:                n.f0.accept(this );
0604:                n.f1.accept(this );
0605:            }
0606:
0607:            /**
0608:             * Visit the specified node.
0609:             * <pre>
0610:             * f0 -> RelationalExpression()
0611:             * f1 -> [ "instanceof" Type() ]
0612:             * </pre>
0613:             */
0614:            public void visit(InstanceOfExpression n) {
0615:                n.f0.accept(this );
0616:                n.f1.accept(this );
0617:            }
0618:
0619:            /**
0620:             * Visit the specified node.
0621:             * <pre>
0622:             * f0 -> ShiftExpression()
0623:             * f1 -> ( ( "&lt;" | "&gt;" | "&lt;=" | "&gt;=" ) ShiftExpression() )*
0624:             * </pre>
0625:             */
0626:            public void visit(RelationalExpression n) {
0627:                n.f0.accept(this );
0628:                n.f1.accept(this );
0629:            }
0630:
0631:            /**
0632:             * Visit the specified node.
0633:             * <pre>
0634:             * f0 -> AdditiveExpression()
0635:             * f1 -> ( ( "&lt;&lt;" | "&gt;&gt;" | "&gt;&gt;&gt;" ) AdditiveExpression() )*
0636:             * </pre>
0637:             */
0638:            public void visit(ShiftExpression n) {
0639:                n.f0.accept(this );
0640:                n.f1.accept(this );
0641:            }
0642:
0643:            /**
0644:             * Visit the specified node.
0645:             * <pre>
0646:             * f0 -> MultiplicativeExpression()
0647:             * f1 -> ( ( "+" | "-" ) MultiplicativeExpression() )*
0648:             * </pre>
0649:             */
0650:            public void visit(AdditiveExpression n) {
0651:                n.f0.accept(this );
0652:                n.f1.accept(this );
0653:            }
0654:
0655:            /**
0656:             * Visit the specified node.
0657:             * <pre>
0658:             * f0 -> UnaryExpression()
0659:             * f1 -> ( ( "*" | "/" | "%" ) UnaryExpression() )*
0660:             * </pre>
0661:             */
0662:            public void visit(MultiplicativeExpression n) {
0663:                n.f0.accept(this );
0664:                n.f1.accept(this );
0665:            }
0666:
0667:            /**
0668:             * Visit the specified node.
0669:             * <pre>
0670:             * f0 -> ( "+" | "-" ) UnaryExpression()
0671:             *       | PreIncrementExpression()
0672:             *       | PreDecrementExpression()
0673:             *       | UnaryExpressionNotPlusMinus()
0674:             * </pre>
0675:             */
0676:            public void visit(UnaryExpression n) {
0677:                n.f0.accept(this );
0678:            }
0679:
0680:            /**
0681:             * Visit the specified node.
0682:             * <pre>
0683:             * f0 -> "++"
0684:             * f1 -> PrimaryExpression()
0685:             * </pre>
0686:             */
0687:            public void visit(PreIncrementExpression n) {
0688:                n.f0.accept(this );
0689:                n.f1.accept(this );
0690:            }
0691:
0692:            /**
0693:             * Visit the specified node.
0694:             * <pre>
0695:             * f0 -> "--"
0696:             * f1 -> PrimaryExpression()
0697:             * </pre>
0698:             */
0699:            public void visit(PreDecrementExpression n) {
0700:                n.f0.accept(this );
0701:                n.f1.accept(this );
0702:            }
0703:
0704:            /**
0705:             * Visit the specified node.
0706:             * <pre>
0707:             * f0 -> ( "~" | "!" ) UnaryExpression()
0708:             *       | CastExpression()
0709:             *       | PostfixExpression()
0710:             * </pre>
0711:             */
0712:            public void visit(UnaryExpressionNotPlusMinus n) {
0713:                n.f0.accept(this );
0714:            }
0715:
0716:            /**
0717:             * Visit the specified node.
0718:             * <pre>
0719:             * f0 -> "(" PrimitiveType()
0720:             *       | "(" Name() "[" "]"
0721:             *       | "(" Name() ")" ( "~" | "!" | "(" | &lt;IDENTIFIER&gt; | "this" | "super" | "new" | Literal() )
0722:             * </pre>
0723:             */
0724:            public void visit(CastLookahead n) {
0725:                n.f0.accept(this );
0726:            }
0727:
0728:            /**
0729:             * Visit the specified node.
0730:             * <pre>
0731:             * f0 -> PrimaryExpression()
0732:             * f1 -> [ "++" | "--" ]
0733:             * </pre>
0734:             */
0735:            public void visit(PostfixExpression n) {
0736:                n.f0.accept(this );
0737:                n.f1.accept(this );
0738:            }
0739:
0740:            /**
0741:             * Visit the specified node.
0742:             * <pre>
0743:             * f0 -> "(" Type() ")" UnaryExpression()
0744:             *       | "(" Type() ")" UnaryExpressionNotPlusMinus()
0745:             * </pre>
0746:             */
0747:            public void visit(CastExpression n) {
0748:                n.f0.accept(this );
0749:            }
0750:
0751:            /**
0752:             * Visit the specified node.
0753:             * <pre>
0754:             * f0 -> PrimaryPrefix()
0755:             * f1 -> ( PrimarySuffix() )*
0756:             * </pre>
0757:             */
0758:            public void visit(PrimaryExpression n) {
0759:                n.f0.accept(this );
0760:                n.f1.accept(this );
0761:            }
0762:
0763:            /**
0764:             * Visit the specified node.
0765:             * <pre>
0766:             * f0 -> Literal()
0767:             *       | "this"
0768:             *       | "super" "." &lt;IDENTIFIER&gt;
0769:             *       | "(" Expression() ")"
0770:             *       | AllocationExpression()
0771:             *       | ResultType() "." "class"
0772:             *       | Name()
0773:             * </pre>
0774:             */
0775:            public void visit(PrimaryPrefix n) {
0776:                n.f0.accept(this );
0777:            }
0778:
0779:            /**
0780:             * Visit the specified node.
0781:             * <pre>
0782:             * f0 -> "." "this"
0783:             *       | "." "super"
0784:             *       | "." AllocationExpression()
0785:             *       | "[" Expression() "]"
0786:             *       | "." &lt;IDENTIFIER&gt;
0787:             *       | Arguments()
0788:             * </pre>
0789:             */
0790:            public void visit(PrimarySuffix n) {
0791:                n.f0.accept(this );
0792:            }
0793:
0794:            /**
0795:             * Visit the specified node.
0796:             * <pre>
0797:             * f0 -> &lt;INTEGER_LITERAL&gt;
0798:             *       | &lt;FLOATING_POINT_LITERAL&gt;
0799:             *       | &lt;CHARACTER_LITERAL&gt;
0800:             *       | &lt;STRING_LITERAL&gt;
0801:             *       | BooleanLiteral()
0802:             *       | NullLiteral()
0803:             * </pre>
0804:             */
0805:            public void visit(Literal n) {
0806:                n.f0.accept(this );
0807:            }
0808:
0809:            /**
0810:             * Visit the specified node.
0811:             * <pre>
0812:             * f0 -> "true"
0813:             *       | "false"
0814:             * </pre>
0815:             */
0816:            public void visit(BooleanLiteral n) {
0817:                n.f0.accept(this );
0818:            }
0819:
0820:            /**
0821:             * Visit the specified node.
0822:             * <pre>
0823:             * f0 -> "null"
0824:             * </pre>
0825:             */
0826:            public void visit(NullLiteral n) {
0827:                n.f0.accept(this );
0828:            }
0829:
0830:            /**
0831:             * Visit the specified node.
0832:             * <pre>
0833:             * f0 -> "("
0834:             * f1 -> [ ArgumentList() ]
0835:             * f2 -> ")"
0836:             * </pre>
0837:             */
0838:            public void visit(Arguments n) {
0839:                n.f0.accept(this );
0840:                n.f1.accept(this );
0841:                n.f2.accept(this );
0842:            }
0843:
0844:            /**
0845:             * Visit the specified node.
0846:             * <pre>
0847:             * f0 -> Expression()
0848:             * f1 -> ( "," Expression() )*
0849:             * </pre>
0850:             */
0851:            public void visit(ArgumentList n) {
0852:                n.f0.accept(this );
0853:                n.f1.accept(this );
0854:            }
0855:
0856:            /**
0857:             * Visit the specified node.
0858:             * <pre>
0859:             * f0 -> "new" PrimitiveType() ArrayDimsAndInits()
0860:             *       | "new" Name() ( ArrayDimsAndInits() | Arguments() [ ClassBody() ] )
0861:             * </pre>
0862:             */
0863:            public void visit(AllocationExpression n) {
0864:                n.f0.accept(this );
0865:            }
0866:
0867:            /**
0868:             * Visit the specified node.
0869:             * <pre>
0870:             * f0 -> ( "[" Expression() "]" )+ ( "[" "]" )*
0871:             *       | ( "[" "]" )+ ArrayInitializer()
0872:             * </pre>
0873:             */
0874:            public void visit(ArrayDimsAndInits n) {
0875:                n.f0.accept(this );
0876:            }
0877:
0878:            /**
0879:             * Visit the specified node.
0880:             * <pre>
0881:             * f0 -> LabeledStatement()
0882:             *       | Block()
0883:             *       | EmptyStatement()
0884:             *       | StatementExpression() ";"
0885:             *       | SwitchStatement()
0886:             *       | IfStatement()
0887:             *       | WhileStatement()
0888:             *       | DoStatement()
0889:             *       | ForStatement()
0890:             *       | BreakStatement()
0891:             *       | ContinueStatement()
0892:             *       | ReturnStatement()
0893:             *       | ThrowStatement()
0894:             *       | SynchronizedStatement()
0895:             *       | TryStatement()
0896:             *       | AssertStatement()
0897:             * </pre>
0898:             */
0899:            public void visit(Statement n) {
0900:                n.f0.accept(this );
0901:            }
0902:
0903:            /**
0904:             * Visit the specified node.
0905:             * <pre>
0906:             * f0 -> &lt;IDENTIFIER&gt;
0907:             * f1 -> ":"
0908:             * f2 -> Statement()
0909:             * </pre>
0910:             */
0911:            public void visit(LabeledStatement n) {
0912:                n.f0.accept(this );
0913:                n.f1.accept(this );
0914:                n.f2.accept(this );
0915:            }
0916:
0917:            /**
0918:             * Visit the specified node.
0919:             * <pre>
0920:             * f0 -> "{"
0921:             * f1 -> ( BlockStatement() )*
0922:             * f2 -> "}"
0923:             * </pre>
0924:             */
0925:            public void visit(Block n) {
0926:                n.f0.accept(this );
0927:                n.f1.accept(this );
0928:                n.f2.accept(this );
0929:            }
0930:
0931:            /**
0932:             * Visit the specified node.
0933:             * <pre>
0934:             * f0 -> LocalVariableDeclaration() ";"
0935:             *       | Statement()
0936:             *       | UnmodifiedClassDeclaration()
0937:             *       | UnmodifiedInterfaceDeclaration()
0938:             * </pre>
0939:             */
0940:            public void visit(BlockStatement n) {
0941:                n.f0.accept(this );
0942:            }
0943:
0944:            /**
0945:             * Visit the specified node.
0946:             * <pre>
0947:             * f0 -> [ "final" ]
0948:             * f1 -> Type()
0949:             * f2 -> VariableDeclarator()
0950:             * f3 -> ( "," VariableDeclarator() )*
0951:             * </pre>
0952:             */
0953:            public void visit(LocalVariableDeclaration n) {
0954:                n.f0.accept(this );
0955:                n.f1.accept(this );
0956:                n.f2.accept(this );
0957:                n.f3.accept(this );
0958:            }
0959:
0960:            /**
0961:             * Visit the specified node.
0962:             * <pre>
0963:             * f0 -> ";"
0964:             * </pre>
0965:             */
0966:            public void visit(EmptyStatement n) {
0967:                n.f0.accept(this );
0968:            }
0969:
0970:            /**
0971:             * Visit the specified node.
0972:             * <pre>
0973:             * f0 -> PreIncrementExpression()
0974:             *       | PreDecrementExpression()
0975:             *       | PrimaryExpression() [ "++" | "--" | AssignmentOperator() Expression() ]
0976:             * </pre>
0977:             */
0978:            public void visit(StatementExpression n) {
0979:                n.f0.accept(this );
0980:            }
0981:
0982:            /**
0983:             * Visit the specified node.
0984:             * <pre>
0985:             * f0 -> "switch"
0986:             * f1 -> "("
0987:             * f2 -> Expression()
0988:             * f3 -> ")"
0989:             * f4 -> "{"
0990:             * f5 -> ( SwitchLabel() ( BlockStatement() )* )*
0991:             * f6 -> "}"
0992:             * </pre>
0993:             */
0994:            public void visit(SwitchStatement n) {
0995:                n.f0.accept(this );
0996:                n.f1.accept(this );
0997:                n.f2.accept(this );
0998:                n.f3.accept(this );
0999:                n.f4.accept(this );
1000:                n.f5.accept(this );
1001:                n.f6.accept(this );
1002:            }
1003:
1004:            /**
1005:             * Visit the specified node.
1006:             * <pre>
1007:             * f0 -> "case" Expression() ":"
1008:             *       | "default" ":"
1009:             * </pre>
1010:             */
1011:            public void visit(SwitchLabel n) {
1012:                n.f0.accept(this );
1013:            }
1014:
1015:            /**
1016:             * Visit the specified node.
1017:             * <pre>
1018:             * f0 -> "if"
1019:             * f1 -> "("
1020:             * f2 -> Expression()
1021:             * f3 -> ")"
1022:             * f4 -> Statement()
1023:             * f5 -> [ "else" Statement() ]
1024:             * </pre>
1025:             */
1026:            public void visit(IfStatement n) {
1027:                n.f0.accept(this );
1028:                n.f1.accept(this );
1029:                n.f2.accept(this );
1030:                n.f3.accept(this );
1031:                n.f4.accept(this );
1032:                n.f5.accept(this );
1033:            }
1034:
1035:            /**
1036:             * Visit the specified node.
1037:             * <pre>
1038:             * f0 -> "while"
1039:             * f1 -> "("
1040:             * f2 -> Expression()
1041:             * f3 -> ")"
1042:             * f4 -> Statement()
1043:             * </pre>
1044:             */
1045:            public void visit(WhileStatement n) {
1046:                n.f0.accept(this );
1047:                n.f1.accept(this );
1048:                n.f2.accept(this );
1049:                n.f3.accept(this );
1050:                n.f4.accept(this );
1051:            }
1052:
1053:            /**
1054:             * Visit the specified node.
1055:             * <pre>
1056:             * f0 -> "do"
1057:             * f1 -> Statement()
1058:             * f2 -> "while"
1059:             * f3 -> "("
1060:             * f4 -> Expression()
1061:             * f5 -> ")"
1062:             * f6 -> ";"
1063:             * </pre>
1064:             */
1065:            public void visit(DoStatement n) {
1066:                n.f0.accept(this );
1067:                n.f1.accept(this );
1068:                n.f2.accept(this );
1069:                n.f3.accept(this );
1070:                n.f4.accept(this );
1071:                n.f5.accept(this );
1072:                n.f6.accept(this );
1073:            }
1074:
1075:            /**
1076:             * Visit the specified node.
1077:             * <pre>
1078:             * f0 -> "for"
1079:             * f1 -> "("
1080:             * f2 -> [ ForInit() ]
1081:             * f3 -> ";"
1082:             * f4 -> [ Expression() ]
1083:             * f5 -> ";"
1084:             * f6 -> [ ForUpdate() ]
1085:             * f7 -> ")"
1086:             * f8 -> Statement()
1087:             * </pre>
1088:             */
1089:            public void visit(ForStatement n) {
1090:                n.f0.accept(this );
1091:                n.f1.accept(this );
1092:                n.f2.accept(this );
1093:                n.f3.accept(this );
1094:                n.f4.accept(this );
1095:                n.f5.accept(this );
1096:                n.f6.accept(this );
1097:                n.f7.accept(this );
1098:                n.f8.accept(this );
1099:            }
1100:
1101:            /**
1102:             * Visit the specified node.
1103:             * <pre>
1104:             * f0 -> LocalVariableDeclaration()
1105:             *       | StatementExpressionList()
1106:             * </pre>
1107:             */
1108:            public void visit(ForInit n) {
1109:                n.f0.accept(this );
1110:            }
1111:
1112:            /**
1113:             * Visit the specified node.
1114:             * <pre>
1115:             * f0 -> StatementExpression()
1116:             * f1 -> ( "," StatementExpression() )*
1117:             * </pre>
1118:             */
1119:            public void visit(StatementExpressionList n) {
1120:                n.f0.accept(this );
1121:                n.f1.accept(this );
1122:            }
1123:
1124:            /**
1125:             * Visit the specified node.
1126:             * <pre>
1127:             * f0 -> StatementExpressionList()
1128:             * </pre>
1129:             */
1130:            public void visit(ForUpdate n) {
1131:                n.f0.accept(this );
1132:            }
1133:
1134:            /**
1135:             * Visit the specified node.
1136:             * <pre>
1137:             * f0 -> "break"
1138:             * f1 -> [ &lt;IDENTIFIER&gt; ]
1139:             * f2 -> ";"
1140:             * </pre>
1141:             */
1142:            public void visit(BreakStatement n) {
1143:                n.f0.accept(this );
1144:                n.f1.accept(this );
1145:                n.f2.accept(this );
1146:            }
1147:
1148:            /**
1149:             * Visit the specified node.
1150:             * <pre>
1151:             * f0 -> "continue"
1152:             * f1 -> [ &lt;IDENTIFIER&gt; ]
1153:             * f2 -> ";"
1154:             * </pre>
1155:             */
1156:            public void visit(ContinueStatement n) {
1157:                n.f0.accept(this );
1158:                n.f1.accept(this );
1159:                n.f2.accept(this );
1160:            }
1161:
1162:            /**
1163:             * Visit the specified node.
1164:             * <pre>
1165:             * f0 -> "return"
1166:             * f1 -> [ Expression() ]
1167:             * f2 -> ";"
1168:             * </pre>
1169:             */
1170:            public void visit(ReturnStatement n) {
1171:                n.f0.accept(this );
1172:                n.f1.accept(this );
1173:                n.f2.accept(this );
1174:            }
1175:
1176:            /**
1177:             * Visit the specified node.
1178:             * <pre>
1179:             * f0 -> "throw"
1180:             * f1 -> Expression()
1181:             * f2 -> ";"
1182:             * </pre>
1183:             */
1184:            public void visit(ThrowStatement n) {
1185:                n.f0.accept(this );
1186:                n.f1.accept(this );
1187:                n.f2.accept(this );
1188:            }
1189:
1190:            /**
1191:             * Visit the specified node.
1192:             * <pre>
1193:             * f0 -> "synchronized"
1194:             * f1 -> "("
1195:             * f2 -> Expression()
1196:             * f3 -> ")"
1197:             * f4 -> Block()
1198:             * </pre>
1199:             */
1200:            public void visit(SynchronizedStatement n) {
1201:                n.f0.accept(this );
1202:                n.f1.accept(this );
1203:                n.f2.accept(this );
1204:                n.f3.accept(this );
1205:                n.f4.accept(this );
1206:            }
1207:
1208:            /**
1209:             * Visit the specified node.
1210:             * <pre>
1211:             * f0 -> "try"
1212:             * f1 -> Block()
1213:             * f2 -> ( "catch" "(" FormalParameter() ")" Block() )*
1214:             * f3 -> [ "finally" Block() ]
1215:             * </pre>
1216:             */
1217:            public void visit(TryStatement n) {
1218:                n.f0.accept(this );
1219:                n.f1.accept(this );
1220:                n.f2.accept(this );
1221:                n.f3.accept(this );
1222:            }
1223:
1224:            /**
1225:             * Visit the specified node.
1226:             * <pre>
1227:             * f0 -> "assert"
1228:             * f1 -> Expression()
1229:             * f2 -> [ ":" Expression() ]
1230:             * f3 -> ";"
1231:             * </pre>
1232:             */
1233:            public void visit(AssertStatement n) {
1234:                n.f0.accept(this);
1235:                n.f1.accept(this);
1236:                n.f2.accept(this);
1237:                n.f3.accept(this);
1238:            }
1239:
1240:        }