GJDepthFirst.java

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

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

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

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

  41.    public R visit(NodeOptional n, A argu) {
  42.       if ( n.present() )
  43.          return n.node.accept(this,argu);
  44.       else
  45.          return null;
  46.    }

  48.    public R visit(NodeSequence n, A argu) {
  49.       R _ret=null;
  50.       int _count=0;
  51.       for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
  52.          e.nextElement().accept(this,argu);
  53.          _count++;
  54.       }
  55.       return _ret;
  56.    }

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

  60.    //
  61.    // User-generated visitor methods below
  62.    //

  64.    /**
  65.     * <PRE>
  66.     * f0 -> ( HtmlBlock() )*
  67.     * f1 -> &lt;EOF&gt;
  68.     * </PRE>
  69.     */
  70.    public R visit(Template n, A argu) {
  71.       R _ret=null;
  72.       n.f0.accept(this, argu);
  73.       n.f1.accept(this, argu);
  74.       return _ret;
  75.    }

  77.    /**
  78.     * <PRE>
  79.     * f0 -> &lt;HTML&gt;
  80.     *       | &lt;HTML_OTHER&gt;
  81.     *       | ES()
  82.     *       | &lt;BEGIN_SSI&gt; SSD() &lt;END_SSI&gt;
  83.     * </PRE>
  84.     */
  85.    public R visit(HtmlBlock n, A argu) {
  86.       R _ret=null;
  87.       n.f0.accept(this, argu);
  88.       return _ret;
  89.    }

  91.    /**
  92.     * <PRE>
  93.     * f0 -> &lt;BEGIN_CALL&gt;
  94.     * f1 -> [ ExprSeq() ]
  95.     * f2 -> &lt;END_CALL&gt;
  96.     * </PRE>
  97.     */
  98.    public R visit(ES n, A argu) {
  99.       R _ret=null;
  100.       n.f0.accept(this, argu);
  101.       n.f1.accept(this, argu);
  102.       n.f2.accept(this, argu);
  103.       return _ret;
  104.    }

  106.    /**
  107.     * <PRE>
  108.     * f0 -> Expression()
  109.     * f1 -> ( &lt;OP_SEMI&gt; Expression() )*
  110.     * </PRE>
  111.     */
  112.    public R visit(ExprSeq n, A argu) {
  113.       R _ret=null;
  114.       n.f0.accept(this, argu);
  115.       n.f1.accept(this, argu);
  116.       return _ret;
  117.    }

  119.    /**
  120.     * <PRE>
  121.     * f0 -> Apply()
  122.     *       | JSObj()
  123.     *       | JSArr()
  124.     *       | Tuple()
  125.     *       | Lambda()
  126.     *       | Let()
  127.     *       | Literal()
  128.     *       | Lift()
  129.     * </PRE>
  130.     */
  131.    public R visit(Expression n, A argu) {
  132.       R _ret=null;
  133.       n.f0.accept(this, argu);
  134.       return _ret;
  135.    }

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

  152.    /**
  153.     * <PRE>
  154.     * f0 -> &lt;L_CURLY&gt;
  155.     * f1 -> [ WithParams() ]
  156.     * f2 -> &lt;R_CURLY&gt;
  157.     * </PRE>
  158.     */
  159.    public R visit(JSObj 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.    }

  167.    /**
  168.     * <PRE>
  169.     * f0 -> &lt;L_BRACE&gt;
  170.     * f1 -> [ Params() ]
  171.     * f2 -> &lt;R_BRACE&gt;
  172.     * </PRE>
  173.     */
  174.    public R visit(JSArr 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.       return _ret;
  180.    }

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

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

  218.    /**
  219.     * <PRE>
  220.     * f0 -> &lt;KW_LET&gt;
  221.     * f1 -> JSObj()
  222.     * f2 -> &lt;L_PAREN&gt;
  223.     * f3 -> ExprSeq()
  224.     * f4 -> &lt;R_PAREN&gt;
  225.     * f5 -> [ Expression() ]
  226.     * </PRE>
  227.     */
  228.    public R visit(Let n, A argu) {
  229.       R _ret=null;
  230.       n.f0.accept(this, argu);
  231.       n.f1.accept(this, argu);
  232.       n.f2.accept(this, argu);
  233.       n.f3.accept(this, argu);
  234.       n.f4.accept(this, argu);
  235.       n.f5.accept(this, argu);
  236.       return _ret;
  237.    }

  239.    /**
  240.     * <PRE>
  241.     * f0 -> &lt;OP_LIFT&gt;
  242.     * f1 -> [ Expression() ]
  243.     * </PRE>
  244.     */
  245.    public R visit(Lift n, A argu) {
  246.       R _ret=null;
  247.       n.f0.accept(this, argu);
  248.       n.f1.accept(this, argu);
  249.       return _ret;
  250.    }

  252.    /**
  253.     * <PRE>
  254.     * f0 -> &lt;DECIMAL_LITERAL&gt;
  255.     *       | &lt;HEX_LITERAL&gt;
  256.     *       | &lt;FLOAT_LITERAL&gt;
  257.     *       | &lt;STRING_LITERAL&gt;
  258.     *       | &lt;SQSTRING_LITERAL&gt;
  259.     *       | &lt;BOOLEAN_LITERAL&gt;
  260.     * </PRE>
  261.     */
  262.    public R visit(Literal n, A argu) {
  263.       R _ret=null;
  264.       n.f0.accept(this, argu);
  265.       return _ret;
  266.    }

  268.    /**
  269.     * <PRE>
  270.     * f0 -> Expression()
  271.     * f1 -> ( &lt;OP_COMMA&gt; Expression() )*
  272.     * </PRE>
  273.     */
  274.    public R visit(Params n, A argu) {
  275.       R _ret=null;
  276.       n.f0.accept(this, argu);
  277.       n.f1.accept(this, argu);
  278.       return _ret;
  279.    }

  281.    /**
  282.     * <PRE>
  283.     * f0 -> WithParam()
  284.     * f1 -> ( &lt;OP_COMMA&gt; WithParam() )*
  285.     * </PRE>
  286.     */
  287.    public R visit(WithParams n, A argu) {
  288.       R _ret=null;
  289.       n.f0.accept(this, argu);
  290.       n.f1.accept(this, argu);
  291.       return _ret;
  292.    }

  294.    /**
  295.     * <PRE>
  296.     * f0 -> &lt;ID&gt;
  297.     *       | &lt;STRING_LITERAL&gt;
  298.     *       | &lt;SQSTRING_LITERAL&gt;
  299.     * </PRE>
  300.     */
  301.    public R visit(Key n, A argu) {
  302.       R _ret=null;
  303.       n.f0.accept(this, argu);
  304.       return _ret;
  305.    }

  307.    /**
  308.     * <PRE>
  309.     * f0 -> Key()
  310.     * f1 -> &lt;OP_WITH&gt;
  311.     * f2 -> Expression()
  312.     * </PRE>
  313.     */
  314.    public R visit(WithParam n, A argu) {
  315.       R _ret=null;
  316.       n.f0.accept(this, argu);
  317.       n.f1.accept(this, argu);
  318.       n.f2.accept(this, argu);
  319.       return _ret;
  320.    }

  322.    /**
  323.     * <PRE>
  324.     * f0 -> Directive()
  325.     * f1 -> &lt;SSIID&gt;
  326.     * f2 -> &lt;SOP_EQ&gt;
  327.     * f3 -> &lt;SSI_STRING_LITERAL&gt;
  328.     * </PRE>
  329.     */
  330.    public R visit(SSD n, A argu) {
  331.       R _ret=null;
  332.       n.f0.accept(this, argu);
  333.       n.f1.accept(this, argu);
  334.       n.f2.accept(this, argu);
  335.       n.f3.accept(this, argu);
  336.       return _ret;
  337.    }

  339.    /**
  340.     * <PRE>
  341.     * f0 -> &lt;KW_INC&gt;
  342.     *       | &lt;KW_ECHO&gt;
  343.     *       | &lt;KW_CONFIG&gt;
  344.     *       | &lt;KW_EXEC&gt;
  345.     *       | &lt;KW_SET&gt;
  346.     *       | &lt;KW_IF&gt;
  347.     *       | &lt;KW_ELIF&gt;
  348.     *       | &lt;KW_ELSE&gt;
  349.     *       | &lt;KW_ENDIF&gt;
  350.     * </PRE>
  351.     */
  352.    public R visit(Directive n, A argu) {
  353.       R _ret=null;
  354.       n.f0.accept(this, argu);
  355.       return _ret;
  356.    }

  358. }
Created with JaCoCo 0.7.5.201505241946