GJDepthFirst.java

  1. //
  2. // Generated by JTB 1.3.2
  3. //

  4. package net.metanotion.simpletemplate.parser.visitor;
  5. import net.metanotion.simpletemplate.parser.syntaxtree.*;
  6. import java.util.*;

  7. /**
  8.  * Provides default methods which visit each node in the tree in depth-first
  9.  * order.  Your visitors may extend this class.
  10.  */
  11. public class GJDepthFirst<R,A> implements GJVisitor<R,A> {
  12.    //
  13.    // Auto class visitors--probably don't need to be overridden.
  14.    //
  15.    public R visit(NodeList n, A argu) {
  16.       R _ret=null;
  17.       int _count=0;
  18.       for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
  19.          e.nextElement().accept(this,argu);
  20.          _count++;
  21.       }
  22.       return _ret;
  23.    }

  24.    public R visit(NodeListOptional n, A argu) {
  25.       if ( n.present() ) {
  26.          R _ret=null;
  27.          int _count=0;
  28.          for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
  29.             e.nextElement().accept(this,argu);
  30.             _count++;
  31.          }
  32.          return _ret;
  33.       }
  34.       else
  35.          return null;
  36.    }

  37.    public R visit(NodeOptional n, A argu) {
  38.       if ( n.present() )
  39.          return n.node.accept(this,argu);
  40.       else
  41.          return null;
  42.    }

  43.    public R visit(NodeSequence n, A argu) {
  44.       R _ret=null;
  45.       int _count=0;
  46.       for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
  47.          e.nextElement().accept(this,argu);
  48.          _count++;
  49.       }
  50.       return _ret;
  51.    }

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

  53.    //
  54.    // User-generated visitor methods below
  55.    //

  56.    /**
  57.     * <PRE>
  58.     * f0 -> ( HtmlBlock() )*
  59.     * f1 -> &lt;EOF&gt;
  60.     * </PRE>
  61.     */
  62.    public R visit(Template n, A argu) {
  63.       R _ret=null;
  64.       n.f0.accept(this, argu);
  65.       n.f1.accept(this, argu);
  66.       return _ret;
  67.    }

  68.    /**
  69.     * <PRE>
  70.     * f0 -> &lt;HTML&gt;
  71.     *       | &lt;HTML_OTHER&gt;
  72.     *       | ES()
  73.     *       | &lt;BEGIN_SSI&gt; SSD() &lt;END_SSI&gt;
  74.     * </PRE>
  75.     */
  76.    public R visit(HtmlBlock n, A argu) {
  77.       R _ret=null;
  78.       n.f0.accept(this, argu);
  79.       return _ret;
  80.    }

  81.    /**
  82.     * <PRE>
  83.     * f0 -> &lt;BEGIN_CALL&gt;
  84.     * f1 -> [ ExprSeq() ]
  85.     * f2 -> &lt;END_CALL&gt;
  86.     * </PRE>
  87.     */
  88.    public R visit(ES n, A argu) {
  89.       R _ret=null;
  90.       n.f0.accept(this, argu);
  91.       n.f1.accept(this, argu);
  92.       n.f2.accept(this, argu);
  93.       return _ret;
  94.    }

  95.    /**
  96.     * <PRE>
  97.     * f0 -> Expression()
  98.     * f1 -> ( &lt;OP_SEMI&gt; Expression() )*
  99.     * </PRE>
  100.     */
  101.    public R visit(ExprSeq n, A argu) {
  102.       R _ret=null;
  103.       n.f0.accept(this, argu);
  104.       n.f1.accept(this, argu);
  105.       return _ret;
  106.    }

  107.    /**
  108.     * <PRE>
  109.     * f0 -> Apply()
  110.     *       | JSObj()
  111.     *       | JSArr()
  112.     *       | Tuple()
  113.     *       | Lambda()
  114.     *       | Let()
  115.     *       | Literal()
  116.     *       | Lift()
  117.     * </PRE>
  118.     */
  119.    public R visit(Expression n, A argu) {
  120.       R _ret=null;
  121.       n.f0.accept(this, argu);
  122.       return _ret;
  123.    }

  124.    /**
  125.     * <PRE>
  126.     * f0 -> &lt;ID&gt;
  127.     * f1 -> ( &lt;OP_DOT&gt; &lt;ID&gt; )*
  128.     * f2 -> [ Expression() ]
  129.     * </PRE>
  130.     */
  131.    public R visit(Apply n, A argu) {
  132.       R _ret=null;
  133.       n.f0.accept(this, argu);
  134.       n.f1.accept(this, argu);
  135.       n.f2.accept(this, argu);
  136.       return _ret;
  137.    }

  138.    /**
  139.     * <PRE>
  140.     * f0 -> &lt;L_CURLY&gt;
  141.     * f1 -> [ WithParams() ]
  142.     * f2 -> &lt;R_CURLY&gt;
  143.     * </PRE>
  144.     */
  145.    public R visit(JSObj n, A argu) {
  146.       R _ret=null;
  147.       n.f0.accept(this, argu);
  148.       n.f1.accept(this, argu);
  149.       n.f2.accept(this, argu);
  150.       return _ret;
  151.    }

  152.    /**
  153.     * <PRE>
  154.     * f0 -> &lt;L_BRACE&gt;
  155.     * f1 -> [ Params() ]
  156.     * f2 -> &lt;R_BRACE&gt;
  157.     * </PRE>
  158.     */
  159.    public R visit(JSArr n, A argu) {
  160.       R _ret=null;
  161.       n.f0.accept(this, argu);
  162.       n.f1.accept(this, argu);
  163.       n.f2.accept(this, argu);
  164.       return _ret;
  165.    }

  166.    /**
  167.     * <PRE>
  168.     * f0 -> &lt;L_PAREN&gt;
  169.     * f1 -> [ Params() ]
  170.     * f2 -> &lt;R_PAREN&gt;
  171.     * f3 -> [ Expression() ]
  172.     * </PRE>
  173.     */
  174.    public R visit(Tuple n, A argu) {
  175.       R _ret=null;
  176.       n.f0.accept(this, argu);
  177.       n.f1.accept(this, argu);
  178.       n.f2.accept(this, argu);
  179.       n.f3.accept(this, argu);
  180.       return _ret;
  181.    }

  182.    /**
  183.     * <PRE>
  184.     * f0 -> &lt;OP_LAMBDA&gt;
  185.     * f1 -> &lt;L_PAREN&gt;
  186.     * f2 -> ExprSeq()
  187.     * f3 -> &lt;R_PAREN&gt;
  188.     * f4 -> [ Expression() ]
  189.     * </PRE>
  190.     */
  191.    public R visit(Lambda n, A argu) {
  192.       R _ret=null;
  193.       n.f0.accept(this, argu);
  194.       n.f1.accept(this, argu);
  195.       n.f2.accept(this, argu);
  196.       n.f3.accept(this, argu);
  197.       n.f4.accept(this, argu);
  198.       return _ret;
  199.    }

  200.    /**
  201.     * <PRE>
  202.     * f0 -> &lt;KW_LET&gt;
  203.     * f1 -> JSObj()
  204.     * f2 -> &lt;L_PAREN&gt;
  205.     * f3 -> ExprSeq()
  206.     * f4 -> &lt;R_PAREN&gt;
  207.     * f5 -> [ Expression() ]
  208.     * </PRE>
  209.     */
  210.    public R visit(Let n, A argu) {
  211.       R _ret=null;
  212.       n.f0.accept(this, argu);
  213.       n.f1.accept(this, argu);
  214.       n.f2.accept(this, argu);
  215.       n.f3.accept(this, argu);
  216.       n.f4.accept(this, argu);
  217.       n.f5.accept(this, argu);
  218.       return _ret;
  219.    }

  220.    /**
  221.     * <PRE>
  222.     * f0 -> &lt;OP_LIFT&gt;
  223.     * f1 -> [ Expression() ]
  224.     * </PRE>
  225.     */
  226.    public R visit(Lift n, A argu) {
  227.       R _ret=null;
  228.       n.f0.accept(this, argu);
  229.       n.f1.accept(this, argu);
  230.       return _ret;
  231.    }

  232.    /**
  233.     * <PRE>
  234.     * f0 -> &lt;DECIMAL_LITERAL&gt;
  235.     *       | &lt;HEX_LITERAL&gt;
  236.     *       | &lt;FLOAT_LITERAL&gt;
  237.     *       | &lt;STRING_LITERAL&gt;
  238.     *       | &lt;SQSTRING_LITERAL&gt;
  239.     *       | &lt;BOOLEAN_LITERAL&gt;
  240.     * </PRE>
  241.     */
  242.    public R visit(Literal n, A argu) {
  243.       R _ret=null;
  244.       n.f0.accept(this, argu);
  245.       return _ret;
  246.    }

  247.    /**
  248.     * <PRE>
  249.     * f0 -> Expression()
  250.     * f1 -> ( &lt;OP_COMMA&gt; Expression() )*
  251.     * </PRE>
  252.     */
  253.    public R visit(Params n, A argu) {
  254.       R _ret=null;
  255.       n.f0.accept(this, argu);
  256.       n.f1.accept(this, argu);
  257.       return _ret;
  258.    }

  259.    /**
  260.     * <PRE>
  261.     * f0 -> WithParam()
  262.     * f1 -> ( &lt;OP_COMMA&gt; WithParam() )*
  263.     * </PRE>
  264.     */
  265.    public R visit(WithParams n, A argu) {
  266.       R _ret=null;
  267.       n.f0.accept(this, argu);
  268.       n.f1.accept(this, argu);
  269.       return _ret;
  270.    }

  271.    /**
  272.     * <PRE>
  273.     * f0 -> &lt;ID&gt;
  274.     *       | &lt;STRING_LITERAL&gt;
  275.     *       | &lt;SQSTRING_LITERAL&gt;
  276.     * </PRE>
  277.     */
  278.    public R visit(Key n, A argu) {
  279.       R _ret=null;
  280.       n.f0.accept(this, argu);
  281.       return _ret;
  282.    }

  283.    /**
  284.     * <PRE>
  285.     * f0 -> Key()
  286.     * f1 -> &lt;OP_WITH&gt;
  287.     * f2 -> Expression()
  288.     * </PRE>
  289.     */
  290.    public R visit(WithParam n, A argu) {
  291.       R _ret=null;
  292.       n.f0.accept(this, argu);
  293.       n.f1.accept(this, argu);
  294.       n.f2.accept(this, argu);
  295.       return _ret;
  296.    }

  297.    /**
  298.     * <PRE>
  299.     * f0 -> Directive()
  300.     * f1 -> &lt;SSIID&gt;
  301.     * f2 -> &lt;SOP_EQ&gt;
  302.     * f3 -> &lt;SSI_STRING_LITERAL&gt;
  303.     * </PRE>
  304.     */
  305.    public R visit(SSD n, A argu) {
  306.       R _ret=null;
  307.       n.f0.accept(this, argu);
  308.       n.f1.accept(this, argu);
  309.       n.f2.accept(this, argu);
  310.       n.f3.accept(this, argu);
  311.       return _ret;
  312.    }

  313.    /**
  314.     * <PRE>
  315.     * f0 -> &lt;KW_INC&gt;
  316.     *       | &lt;KW_ECHO&gt;
  317.     *       | &lt;KW_CONFIG&gt;
  318.     *       | &lt;KW_EXEC&gt;
  319.     *       | &lt;KW_SET&gt;
  320.     *       | &lt;KW_IF&gt;
  321.     *       | &lt;KW_ELIF&gt;
  322.     *       | &lt;KW_ELSE&gt;
  323.     *       | &lt;KW_ENDIF&gt;
  324.     * </PRE>
  325.     */
  326.    public R visit(Directive n, A argu) {
  327.       R _ret=null;
  328.       n.f0.accept(this, argu);
  329.       return _ret;
  330.    }

  331. }