//
// Generated by JTB 1.3.2 DIT@UoA patched
//

package visitor;
import syntaxtree.*;
import java.util.*;

/**
 * Provides default methods which visit each node in the tree in depth-first
 * order.  Your visitors may extend this class.
 */
public class GJDepthFirst<R,A> implements GJVisitor<R,A> {
   //
   // Auto class visitors--probably don't need to be overridden.
   //
   public R visit(NodeList n, A argu) {
      if (n.size() == 1)
         return n.elementAt(0).accept(this,argu);
      R _ret=null;
      int _count=0;
      for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
         e.nextElement().accept(this,argu);
         _count++;
      }
      return _ret;
   }

   public R visit(NodeListOptional n, A argu) {
      if ( n.present() ) {
         if (n.size() == 1)
            return n.elementAt(0).accept(this,argu);
         R _ret=null;
         int _count=0;
         for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
            e.nextElement().accept(this,argu);
            _count++;
         }
         return _ret;
      }
      else
         return null;
   }

   public R visit(NodeOptional n, A argu) {
      if ( n.present() )
         return n.node.accept(this,argu);
      else
         return null;
   }

   public R visit(NodeSequence n, A argu) {
      if (n.size() == 1)
         return n.elementAt(0).accept(this,argu);
      R _ret=null;
      int _count=0;
      for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
         e.nextElement().accept(this,argu);
         _count++;
      }
      return _ret;
   }

   public R visit(NodeToken n, A argu) { return null; }

   //
   // User-generated visitor methods below
   //

   /**
    * f0 -> AdditiveExpression()
    * f1 -> <EOF>
    */
   public R visit(Goal n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   /**
    * f0 -> MultiplicativeExpression()
    * f1 -> AdditiveExpressionTail()
    */
   public R visit(AdditiveExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   /**
    * f0 -> ( AdditiveExpressionTerm() )*
    */
   public R visit(AdditiveExpressionTail n, A argu) {
      return n.f0.accept(this, argu);
   }

   /**
    * f0 -> PlusExpression()
    *       | MinusExpression()
    */
   public R visit(AdditiveExpressionTerm n, A argu) {
      return n.f0.accept(this, argu);
   }

   /**
    * f0 -> "+"
    * f1 -> MultiplicativeExpression()
    */
   public R visit(PlusExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   /**
    * f0 -> "-"
    * f1 -> MultiplicativeExpression()
    */
   public R visit(MinusExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   /**
    * f0 -> PrimaryExpression()
    * f1 -> MultiplicativeExpressionTail()
    */
   public R visit(MultiplicativeExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   /**
    * f0 -> ( MultiplicativeExpressionTerm() )*
    */
   public R visit(MultiplicativeExpressionTail n, A argu) {
      return n.f0.accept(this, argu);
   }

   /**
    * f0 -> MultExpression()
    *       | DivExpression()
    */
   public R visit(MultiplicativeExpressionTerm n, A argu) {
      return n.f0.accept(this, argu);
   }

   /**
    * f0 -> "*"
    * f1 -> PrimaryExpression()
    */
   public R visit(MultExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   /**
    * f0 -> "/"
    * f1 -> PrimaryExpression()
    */
   public R visit(DivExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   /**
    * f0 -> Constant()
    *       | BracketExpression()
    */
   public R visit(PrimaryExpression n, A argu) {
      return n.f0.accept(this, argu);
   }

   /**
    * f0 -> "("
    * f1 -> AdditiveExpression()
    * f2 -> ")"
    */
   public R visit(BracketExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   /**
    * f0 -> <NUMBER>
    */
   public R visit(Constant n, A argu) {
      return n.f0.accept(this, argu);
   }

}