src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/DepthFirstVisitor.java

   1 //
   2 // Generated by JTB 1.3.2
   3 //
   4
   5 package org.gnunet.seaspider.parser.visitors;
   6 import org.gnunet.seaspider.parser.nodes.*;
   7
   8 import java.util.*;
   9
  10 /**
  11  * Provides default methods which visit each node in the tree in depth-first
  12  * order.  Your visitors may extend this class.
  13  */
  14 public class DepthFirstVisitor implements Visitor {
  15    //
  16    // Auto class visitors--probably don't need to be overridden.
  17    //
  18    public void visit(NodeList n) {
  19       for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); )
  20          e.nextElement().accept(this);
  21    }
  22
  23    public void visit(NodeListOptional n) {
  24       if ( n.present() )
  25          for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); )
  26             e.nextElement().accept(this);
  27    }
  28
  29    public void visit(NodeOptional n) {
  30       if ( n.present() )
  31          n.node.accept(this);
  32    }
  33
  34    public void visit(NodeSequence n) {
  35       for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); )
  36          e.nextElement().accept(this);
  37    }
  38
  39    public void visit(NodeToken n) { }
  40
  41    //
  42    // User-generated visitor methods below
  43    //
  44
  45    /**
  46     * <PRE>
  47     * f0 -> ( ExternalDeclaration() )+
  48     * </PRE>
  49     */
  50    public void visit(TranslationUnit n) {
  51       n.f0.accept(this);
  52    }
  53
  54    /**
  55     * <PRE>
  56     * f0 -> ( StorageClassSpecifier() )*
  57     * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
  58     * </PRE>
  59     */
  60    public void visit(ExternalDeclaration n) {
  61       n.f0.accept(this);
  62       n.f1.accept(this);
  63    }
  64
  65    /**
  66     * <PRE>
  67     * f0 -> TypeSpecifier()
  68     * f1 -> &lt;IDENTIFIER&gt;
  69     * f2 -> "("
  70     * f3 -> [ ParameterList() ]
  71     * f4 -> ")"
  72     * f5 -> ( ";" | CompoundStatement() )
  73     * </PRE>
  74     */
  75    public void visit(FunctionDeclaration n) {
  76       n.f0.accept(this);
  77       n.f1.accept(this);
  78       n.f2.accept(this);
  79       n.f3.accept(this);
  80       n.f4.accept(this);
  81       n.f5.accept(this);
  82    }
  83
  84    /**
  85     * <PRE>
  86     * f0 -> ( &lt;STATIC&gt; | &lt;EXTERN&gt; )
  87     * </PRE>
  88     */
  89    public void visit(StorageClassSpecifier n) {
  90       n.f0.accept(this);
  91    }
  92
  93    /**
  94     * <PRE>
  95     * f0 -> &lt;TYPEDEF&gt;
  96     * f1 -> ( DataType() | FunctionType() )
  97     * f2 -> ";"
  98     * </PRE>
  99     */
 100    public void visit(TypeDeclaration n) {
 101       n.f0.accept(this);
 102       n.f1.accept(this);
 103       n.f2.accept(this);
 104    }
 105
 106    /**
 107     * <PRE>
 108     * f0 -> StructOrUnionSpecifier()
 109     * f1 -> &lt;IDENTIFIER&gt;
 110     * </PRE>
 111     */
 112    public void visit(DataType n) {
 113       n.f0.accept(this);
 114       n.f1.accept(this);
 115    }
 116
 117    /**
 118     * <PRE>
 119     * f0 -> TypeSpecifier()
 120     * f1 -> "("
 121     * f2 -> "*"
 122     * f3 -> &lt;IDENTIFIER&gt;
 123     * f4 -> ")"
 124     * f5 -> "("
 125     * f6 -> [ ParameterList() ]
 126     * f7 -> ")"
 127     * </PRE>
 128     */
 129    public void visit(FunctionType n) {
 130       n.f0.accept(this);
 131       n.f1.accept(this);
 132       n.f2.accept(this);
 133       n.f3.accept(this);
 134       n.f4.accept(this);
 135       n.f5.accept(this);
 136       n.f6.accept(this);
 137       n.f7.accept(this);
 138    }
 139
 140    /**
 141     * <PRE>
 142     * f0 -> ParameterDeclaration()
 143     * f1 -> ( "," ParameterDeclaration() )*
 144     * f2 -> [ "," "..." ]
 145     * </PRE>
 146     */
 147    public void visit(ParameterList n) {
 148       n.f0.accept(this);
 149       n.f1.accept(this);
 150       n.f2.accept(this);
 151    }
 152
 153    /**
 154     * <PRE>
 155     * f0 -> TypeSpecifier()
 156     * f1 -> &lt;IDENTIFIER&gt;
 157     * f2 -> [ Array() ]
 158     * </PRE>
 159     */
 160    public void visit(ParameterDeclaration n) {
 161       n.f0.accept(this);
 162       n.f1.accept(this);
 163       n.f2.accept(this);
 164    }
 165
 166    /**
 167     * <PRE>
 168     * f0 -> VariableClassSpecifier()
 169     * f1 -> TypeSpecifier()
 170     * f2 -> InitDeclaratorList()
 171     * f3 -> ";"
 172     * </PRE>
 173     */
 174    public void visit(VariableDeclaration n) {
 175       n.f0.accept(this);
 176       n.f1.accept(this);
 177       n.f2.accept(this);
 178       n.f3.accept(this);
 179    }
 180
 181    /**
 182     * <PRE>
 183     * f0 -> [ &lt;STATIC&gt; ]
 184     * f1 -> VariableDeclaration()
 185     * </PRE>
 186     */
 187    public void visit(LocalVariableDeclaration n) {
 188       n.f0.accept(this);
 189       n.f1.accept(this);
 190    }
 191
 192    /**
 193     * <PRE>
 194     * f0 -> ( &lt;AUTO&gt; | &lt;REGISTER&gt; )*
 195     * </PRE>
 196     */
 197    public void visit(VariableClassSpecifier n) {
 198       n.f0.accept(this);
 199    }
 200
 201    /**
 202     * <PRE>
 203     * f0 -> [ &lt;CONST&gt; ]
 204     * f1 -> ( &lt;VOID&gt; | &lt;CHAR&gt; | &lt;SHORT&gt; [ &lt;INT&gt; ] | &lt;INT&gt; | &lt;LONG&gt; [ &lt;LONG&gt; ] | &lt;FLOAT&gt; | &lt;DOUBLE&gt; | ( &lt;SIGNED&gt; | &lt;UNSIGNED&gt; ) [ &lt;CHAR&gt; | &lt;SHORT&gt; [ &lt;INT&gt; ] | &lt;INT&gt; | &lt;LONG&gt; [ &lt;LONG&gt; ] ] | StructOrUnionSpecifier() | EnumSpecifier() | &lt;IDENTIFIER&gt; )
 205     * f2 -> [ Pointer() ]
 206     * f3 -> [ Array() ]
 207     * </PRE>
 208     */
 209    public void visit(TypeSpecifier n) {
 210       n.f0.accept(this);
 211       n.f1.accept(this);
 212       n.f2.accept(this);
 213       n.f3.accept(this);
 214    }
 215
 216    /**
 217     * <PRE>
 218     * f0 -> [ &lt;CONST&gt; ]
 219     * f1 -> ( &lt;VOID&gt; | &lt;CHAR&gt; | &lt;SHORT&gt; [ &lt;INT&gt; ] | &lt;INT&gt; | &lt;LONG&gt; [ &lt;LONG&gt; ] | &lt;FLOAT&gt; | &lt;DOUBLE&gt; | ( &lt;SIGNED&gt; | &lt;UNSIGNED&gt; ) [ &lt;CHAR&gt; | &lt;SHORT&gt; [ &lt;INT&gt; ] | &lt;INT&gt; | &lt;LONG&gt; [ &lt;LONG&gt; ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
 220     * f2 -> [ Pointer() ]
 221     * f3 -> [ Array() ]
 222     * </PRE>
 223     */
 224    public void visit(NoIdentifierTypeSpecifier n) {
 225       n.f0.accept(this);
 226       n.f1.accept(this);
 227       n.f2.accept(this);
 228       n.f3.accept(this);
 229    }
 230
 231    /**
 232     * <PRE>
 233     * f0 -> StructOrUnion() [ &lt;IDENTIFIER&gt; ] "{" StructDeclarationList() "}"
 234     *       | StructOrUnion() &lt;IDENTIFIER&gt;
 235     * </PRE>
 236     */
 237    public void visit(StructOrUnionSpecifier n) {
 238       n.f0.accept(this);
 239    }
 240
 241    /**
 242     * <PRE>
 243     * f0 -> ( &lt;STRUCT&gt; | &lt;UNION&gt; )
 244     * </PRE>
 245     */
 246    public void visit(StructOrUnion n) {
 247       n.f0.accept(this);
 248    }
 249
 250    /**
 251     * <PRE>
 252     * f0 -> ( StructDeclaration() )+
 253     * </PRE>
 254     */
 255    public void visit(StructDeclarationList n) {
 256       n.f0.accept(this);
 257    }
 258
 259    /**
 260     * <PRE>
 261     * f0 -> InitDeclarator()
 262     * f1 -> ( "," InitDeclarator() )*
 263     * </PRE>
 264     */
 265    public void visit(InitDeclaratorList n) {
 266       n.f0.accept(this);
 267       n.f1.accept(this);
 268    }
 269
 270    /**
 271     * <PRE>
 272     * f0 -> &lt;IDENTIFIER&gt;
 273     * f1 -> [ Array() ]
 274     * f2 -> [ "=" Initializer() ]
 275     * </PRE>
 276     */
 277    public void visit(InitDeclarator n) {
 278       n.f0.accept(this);
 279       n.f1.accept(this);
 280       n.f2.accept(this);
 281    }
 282
 283    /**
 284     * <PRE>
 285     * f0 -> TypeSpecifier()
 286     * f1 -> &lt;IDENTIFIER&gt;
 287     * f2 -> [ Array() | ":" ConstantExpression() ]
 288     * f3 -> [ &lt;IDENTIFIER&gt; ]
 289     * f4 -> ";"
 290     * </PRE>
 291     */
 292    public void visit(StructDeclaration n) {
 293       n.f0.accept(this);
 294       n.f1.accept(this);
 295       n.f2.accept(this);
 296       n.f3.accept(this);
 297       n.f4.accept(this);
 298    }
 299
 300    /**
 301     * <PRE>
 302     * f0 -> &lt;ENUM&gt;
 303     * f1 -> ( [ &lt;IDENTIFIER&gt; ] "{" EnumeratorList() "}" | &lt;IDENTIFIER&gt; )
 304     * </PRE>
 305     */
 306    public void visit(EnumSpecifier n) {
 307       n.f0.accept(this);
 308       n.f1.accept(this);
 309    }
 310
 311    /**
 312     * <PRE>
 313     * f0 -> Enumerator()
 314     * f1 -> ( "," Enumerator() )*
 315     * </PRE>
 316     */
 317    public void visit(EnumeratorList n) {
 318       n.f0.accept(this);
 319       n.f1.accept(this);
 320    }
 321
 322    /**
 323     * <PRE>
 324     * f0 -> &lt;IDENTIFIER&gt;
 325     * f1 -> [ "=" ConstantExpression() ]
 326     * </PRE>
 327     */
 328    public void visit(Enumerator n) {
 329       n.f0.accept(this);
 330       n.f1.accept(this);
 331    }
 332
 333    /**
 334     * <PRE>
 335     * f0 -> "*"
 336     * f1 -> [ &lt;CONST&gt; ]
 337     * f2 -> [ Pointer() ]
 338     * </PRE>
 339     */
 340    public void visit(Pointer n) {
 341       n.f0.accept(this);
 342       n.f1.accept(this);
 343       n.f2.accept(this);
 344    }
 345
 346    /**
 347     * <PRE>
 348     * f0 -> &lt;IDENTIFIER&gt;
 349     * f1 -> ( "," &lt;IDENTIFIER&gt; )*
 350     * </PRE>
 351     */
 352    public void visit(IdentifierList n) {
 353       n.f0.accept(this);
 354       n.f1.accept(this);
 355    }
 356
 357    /**
 358     * <PRE>
 359     * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
 360     * </PRE>
 361     */
 362    public void visit(Initializer n) {
 363       n.f0.accept(this);
 364    }
 365
 366    /**
 367     * <PRE>
 368     * f0 -> Initializer()
 369     * f1 -> ( "," Initializer() )*
 370     * </PRE>
 371     */
 372    public void visit(InitializerList n) {
 373       n.f0.accept(this);
 374       n.f1.accept(this);
 375    }
 376
 377    /**
 378     * <PRE>
 379     * f0 -> "["
 380     * f1 -> [ ConstantExpression() ]
 381     * f2 -> "]"
 382     * </PRE>
 383     */
 384    public void visit(Array n) {
 385       n.f0.accept(this);
 386       n.f1.accept(this);
 387       n.f2.accept(this);
 388    }
 389
 390    /**
 391     * <PRE>
 392     * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
 393     * </PRE>
 394     */
 395    public void visit(Statement n) {
 396       n.f0.accept(this);
 397    }
 398
 399    /**
 400     * <PRE>
 401     * f0 -> ( &lt;IDENTIFIER&gt; ":" Statement() | &lt;CASE&gt; ConstantExpression() ":" Statement() | &lt;DFLT&gt; ":" Statement() )
 402     * </PRE>
 403     */
 404    public void visit(LabeledStatement n) {
 405       n.f0.accept(this);
 406    }
 407
 408    /**
 409     * <PRE>
 410     * f0 -> [ Expression() ]
 411     * f1 -> ";"
 412     * </PRE>
 413     */
 414    public void visit(ExpressionStatement n) {
 415       n.f0.accept(this);
 416       n.f1.accept(this);
 417    }
 418
 419    /**
 420     * <PRE>
 421     * f0 -> "{"
 422     * f1 -> ( LocalVariableDeclaration() | Statement() )*
 423     * f2 -> "}"
 424     * </PRE>
 425     */
 426    public void visit(CompoundStatement n) {
 427       n.f0.accept(this);
 428       n.f1.accept(this);
 429       n.f2.accept(this);
 430    }
 431
 432    /**
 433     * <PRE>
 434     * f0 -> ( &lt;IF&gt; "(" Expression() ")" Statement() [ &lt;ELSE&gt; Statement() ] | &lt;SWITCH&gt; "(" Expression() ")" Statement() )
 435     * </PRE>
 436     */
 437    public void visit(SelectionStatement n) {
 438       n.f0.accept(this);
 439    }
 440
 441    /**
 442     * <PRE>
 443     * f0 -> ( &lt;WHILE&gt; "(" Expression() ")" Statement() | &lt;DO&gt; Statement() &lt;WHILE&gt; "(" Expression() ")" ";" | &lt;FOR&gt; "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
 444     * </PRE>
 445     */
 446    public void visit(IterationStatement n) {
 447       n.f0.accept(this);
 448    }
 449
 450    /**
 451     * <PRE>
 452     * f0 -> ( &lt;GOTO&gt; &lt;IDENTIFIER&gt; ";" | &lt;CONTINUE&gt; ";" | &lt;BREAK&gt; ";" | &lt;RETURN&gt; [ Expression() ] ";" )
 453     * </PRE>
 454     */
 455    public void visit(JumpStatement n) {
 456       n.f0.accept(this);
 457    }
 458
 459    /**
 460     * <PRE>
 461     * f0 -> AssignmentExpression()
 462     * f1 -> ( "," AssignmentExpression() )*
 463     * </PRE>
 464     */
 465    public void visit(Expression n) {
 466       n.f0.accept(this);
 467       n.f1.accept(this);
 468    }
 469
 470    /**
 471     * <PRE>
 472     * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
 473     *       | ConditionalExpression()
 474     * </PRE>
 475     */
 476    public void visit(AssignmentExpression n) {
 477       n.f0.accept(this);
 478    }
 479
 480    /**
 481     * <PRE>
 482     * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "&lt;&lt;=" | "&gt;&gt;=" | "&=" | "^=" | "|=" )
 483     * </PRE>
 484     */
 485    public void visit(AssignmentOperator n) {
 486       n.f0.accept(this);
 487    }
 488
 489    /**
 490     * <PRE>
 491     * f0 -> LogicalORExpression()
 492     * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
 493     * </PRE>
 494     */
 495    public void visit(ConditionalExpression n) {
 496       n.f0.accept(this);
 497       n.f1.accept(this);
 498    }
 499
 500    /**
 501     * <PRE>
 502     * f0 -> ConditionalExpression()
 503     * </PRE>
 504     */
 505    public void visit(ConstantExpression n) {
 506       n.f0.accept(this);
 507    }
 508
 509    /**
 510     * <PRE>
 511     * f0 -> LogicalANDExpression()
 512     * f1 -> [ "||" LogicalORExpression() ]
 513     * </PRE>
 514     */
 515    public void visit(LogicalORExpression n) {
 516       n.f0.accept(this);
 517       n.f1.accept(this);
 518    }
 519
 520    /**
 521     * <PRE>
 522     * f0 -> InclusiveORExpression()
 523     * f1 -> [ "&&" LogicalANDExpression() ]
 524     * </PRE>
 525     */
 526    public void visit(LogicalANDExpression n) {
 527       n.f0.accept(this);
 528       n.f1.accept(this);
 529    }
 530
 531    /**
 532     * <PRE>
 533     * f0 -> ExclusiveORExpression()
 534     * f1 -> [ "|" InclusiveORExpression() ]
 535     * </PRE>
 536     */
 537    public void visit(InclusiveORExpression n) {
 538       n.f0.accept(this);
 539       n.f1.accept(this);
 540    }
 541
 542    /**
 543     * <PRE>
 544     * f0 -> ANDExpression()
 545     * f1 -> [ "^" ExclusiveORExpression() ]
 546     * </PRE>
 547     */
 548    public void visit(ExclusiveORExpression n) {
 549       n.f0.accept(this);
 550       n.f1.accept(this);
 551    }
 552
 553    /**
 554     * <PRE>
 555     * f0 -> EqualityExpression()
 556     * f1 -> [ "&" ANDExpression() ]
 557     * </PRE>
 558     */
 559    public void visit(ANDExpression n) {
 560       n.f0.accept(this);
 561       n.f1.accept(this);
 562    }
 563
 564    /**
 565     * <PRE>
 566     * f0 -> RelationalExpression()
 567     * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
 568     * </PRE>
 569     */
 570    public void visit(EqualityExpression n) {
 571       n.f0.accept(this);
 572       n.f1.accept(this);
 573    }
 574
 575    /**
 576     * <PRE>
 577     * f0 -> ShiftExpression()
 578     * f1 -> [ ( "&lt;" | "&gt;" | "&lt;=" | "&gt;=" ) RelationalExpression() ]
 579     * </PRE>
 580     */
 581    public void visit(RelationalExpression n) {
 582       n.f0.accept(this);
 583       n.f1.accept(this);
 584    }
 585
 586    /**
 587     * <PRE>
 588     * f0 -> AdditiveExpression()
 589     * f1 -> [ ( "&lt;&lt;" | "&gt;&gt;" ) ShiftExpression() ]
 590     * </PRE>
 591     */
 592    public void visit(ShiftExpression n) {
 593       n.f0.accept(this);
 594       n.f1.accept(this);
 595    }
 596
 597    /**
 598     * <PRE>
 599     * f0 -> MultiplicativeExpression()
 600     * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
 601     * </PRE>
 602     */
 603    public void visit(AdditiveExpression n) {
 604       n.f0.accept(this);
 605       n.f1.accept(this);
 606    }
 607
 608    /**
 609     * <PRE>
 610     * f0 -> CastExpression()
 611     * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
 612     * </PRE>
 613     */
 614    public void visit(MultiplicativeExpression n) {
 615       n.f0.accept(this);
 616       n.f1.accept(this);
 617    }
 618
 619    /**
 620     * <PRE>
 621     * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
 622     * </PRE>
 623     */
 624    public void visit(CastExpression n) {
 625       n.f0.accept(this);
 626    }
 627
 628    /**
 629     * <PRE>
 630     * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | &lt;SIZEOF&gt; ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
 631     * </PRE>
 632     */
 633    public void visit(UnaryExpression n) {
 634       n.f0.accept(this);
 635    }
 636
 637    /**
 638     * <PRE>
 639     * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
 640     * </PRE>
 641     */
 642    public void visit(UnaryOperator n) {
 643       n.f0.accept(this);
 644    }
 645
 646    /**
 647     * <PRE>
 648     * f0 -> PrimaryExpression()
 649     * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." &lt;IDENTIFIER&gt; | "-&gt;" &lt;IDENTIFIER&gt; | "++" | "--" )*
 650     * </PRE>
 651     */
 652    public void visit(PostfixExpression n) {
 653       n.f0.accept(this);
 654       n.f1.accept(this);
 655    }
 656
 657    /**
 658     * <PRE>
 659     * f0 -> &lt;IDENTIFIER&gt;
 660     *       | Constant()
 661     *       | "(" Expression() ")"
 662     * </PRE>
 663     */
 664    public void visit(PrimaryExpression n) {
 665       n.f0.accept(this);
 666    }
 667
 668    /**
 669     * <PRE>
 670     * f0 -> AssignmentOrTypeExpression()
 671     * f1 -> ( "," AssignmentOrTypeExpression() )*
 672     * </PRE>
 673     */
 674    public void visit(ArgumentExpressionList n) {
 675       n.f0.accept(this);
 676       n.f1.accept(this);
 677    }
 678
 679    /**
 680     * <PRE>
 681     * f0 -> NoIdentifierTypeSpecifier()
 682     *       | AssignmentExpression()
 683     * </PRE>
 684     */
 685    public void visit(AssignmentOrTypeExpression n) {
 686       n.f0.accept(this);
 687    }
 688
 689    /**
 690     * <PRE>
 691     * f0 -> &lt;INTEGER_LITERAL&gt;
 692     *       | &lt;FLOATING_POINT_LITERAL&gt;
 693     *       | &lt;CHARACTER_LITERAL&gt;
 694     *       | &lt;STRING_LITERAL&gt;
 695     * </PRE>
 696     */
 697    public void visit(Constant n) {
 698       n.f0.accept(this);
 699    }
 700
 701 }