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