1. /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */

  2. package org.apache.commons.jexl.parser;

  3. 

  4. import java.io.Reader;

  5. 

  6. public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/

  7.   protected JJTParserState jjtree = new JJTParserState();public SimpleNode parse(Reader reader)

  8.         throws Exception

  9.     {

  10.         ReInit(reader);

  11. 

  12.         /*

  13.          *  lets do the 'Unique Init' in here to be

  14.          *  safe - it's a pain to remember

  15.          */

  16. 

  17.         SimpleNode tree = JexlScript();

  18.         return tree;

  19.     }

  20. 

  21. /*

  22.  * Program structuring syntax follows.

  23.  */

  24.   final public SimpleNode JexlScript() throws ParseException {

  25.  /*@bgen(jjtree) JexlScript */

  26.    ASTJexlScript jjtn000 = new ASTJexlScript(this, JJTJEXLSCRIPT);

  27.    boolean jjtc000 = true;

  28.    jjtree.openNodeScope(jjtn000);String name;

  29.     try {

  30.       label_1:

  31.       while (true) {

  32.         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  33.         case INTEGER_LITERAL:

  34.         case FLOAT_LITERAL:

  35.         case 9:

  36.         case 11:

  37.         case 12:

  38.         case 14:

  39.         case 36:

  40.         case 42:

  41.         case 43:

  42.         case 44:

  43.         case 45:

  44.         case 46:

  45.         case 47:

  46.         case 48:

  47.         case 49:

  48.         case 51:

  49.         case 52:

  50.         case IDENTIFIER:

  51.         case STRING_LITERAL:

  52.           ;

  53.           break;

  54.         default:

  55.           jj_la1[0] = jj_gen;

  56.           break label_1;

  57.         }

  58.         Statement();

  59.       }

  60.       jj_consume_token(0);

  61.      jjtree.closeNodeScope(jjtn000, true);

  62.      jjtc000 = false;

  63.      {if (true) return jjtn000;}

  64.     } catch (Throwable jjte000) {

  65.       if (jjtc000) {

  66.         jjtree.clearNodeScope(jjtn000);

  67.         jjtc000 = false;

  68.       } else {

  69.         jjtree.popNode();

  70.       }

  71.       if (jjte000 instanceof RuntimeException) {

  72.         {if (true) throw (RuntimeException)jjte000;}

  73.       }

  74.       if (jjte000 instanceof ParseException) {

  75.         {if (true) throw (ParseException)jjte000;}

  76.       }

  77.       {if (true) throw (Error)jjte000;}

  78.     } finally {

  79.       if (jjtc000) {

  80.         jjtree.closeNodeScope(jjtn000, true);

  81.       }

  82.     }

  83.     throw new Error("Missing return statement in function");

  84.   }

  85. 

  86.   final public void Block() throws ParseException {

  87.  /*@bgen(jjtree) Block */

  88.   ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);

  89.   boolean jjtc000 = true;

  90.   jjtree.openNodeScope(jjtn000);

  91.     try {

  92.       jj_consume_token(9);

  93.       label_2:

  94.       while (true) {

  95.         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  96.         case INTEGER_LITERAL:

  97.         case FLOAT_LITERAL:

  98.         case 9:

  99.         case 11:

  100.         case 12:

  101.         case 14:

  102.         case 36:

  103.         case 42:

  104.         case 43:

  105.         case 44:

  106.         case 45:

  107.         case 46:

  108.         case 47:

  109.         case 48:

  110.         case 49:

  111.         case 51:

  112.         case 52:

  113.         case IDENTIFIER:

  114.         case STRING_LITERAL:

  115.           ;

  116.           break;

  117.         default:

  118.           jj_la1[1] = jj_gen;

  119.           break label_2;

  120.         }

  121.         Statement();

  122.       }

  123.       jj_consume_token(10);

  124.     } catch (Throwable jjte000) {

  125.     if (jjtc000) {

  126.       jjtree.clearNodeScope(jjtn000);

  127.       jjtc000 = false;

  128.     } else {

  129.       jjtree.popNode();

  130.     }

  131.     if (jjte000 instanceof RuntimeException) {

  132.       {if (true) throw (RuntimeException)jjte000;}

  133.     }

  134.     if (jjte000 instanceof ParseException) {

  135.       {if (true) throw (ParseException)jjte000;}

  136.     }

  137.     {if (true) throw (Error)jjte000;}

  138.     } finally {

  139.     if (jjtc000) {

  140.       jjtree.closeNodeScope(jjtn000, true);

  141.     }

  142.     }

  143.   }

  144. 

  145.   final public void EmptyFunction() throws ParseException {

  146.                         /*@bgen(jjtree) EmptyFunction */

  147.   ASTEmptyFunction jjtn000 = new ASTEmptyFunction(this, JJTEMPTYFUNCTION);

  148.   boolean jjtc000 = true;

  149.   jjtree.openNodeScope(jjtn000);

  150.     try {

  151.       jj_consume_token(11);

  152.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  153.       case IDENTIFIER:

  154.         Reference();

  155.         break;

  156.       case 12:

  157.         jj_consume_token(12);

  158.         Reference();

  159.         jj_consume_token(13);

  160.         break;

  161.       default:

  162.         jj_la1[2] = jj_gen;

  163.         jj_consume_token(-1);

  164.         throw new ParseException();

  165.       }

  166.     } catch (Throwable jjte000) {

  167.       if (jjtc000) {

  168.         jjtree.clearNodeScope(jjtn000);

  169.         jjtc000 = false;

  170.       } else {

  171.         jjtree.popNode();

  172.       }

  173.       if (jjte000 instanceof RuntimeException) {

  174.         {if (true) throw (RuntimeException)jjte000;}

  175.       }

  176.       if (jjte000 instanceof ParseException) {

  177.         {if (true) throw (ParseException)jjte000;}

  178.       }

  179.       {if (true) throw (Error)jjte000;}

  180.     } finally {

  181.       if (jjtc000) {

  182.         jjtree.closeNodeScope(jjtn000, true);

  183.       }

  184.     }

  185.   }

  186. 

  187.   final public void SizeFunction() throws ParseException {

  188.                        /*@bgen(jjtree) SizeFunction */

  189.   ASTSizeFunction jjtn000 = new ASTSizeFunction(this, JJTSIZEFUNCTION);

  190.   boolean jjtc000 = true;

  191.   jjtree.openNodeScope(jjtn000);

  192.     try {

  193.       jj_consume_token(14);

  194.       jj_consume_token(12);

  195.       Reference();

  196.       jj_consume_token(13);

  197.     } catch (Throwable jjte000) {

  198.       if (jjtc000) {

  199.         jjtree.clearNodeScope(jjtn000);

  200.         jjtc000 = false;

  201.       } else {

  202.         jjtree.popNode();

  203.       }

  204.       if (jjte000 instanceof RuntimeException) {

  205.         {if (true) throw (RuntimeException)jjte000;}

  206.       }

  207.       if (jjte000 instanceof ParseException) {

  208.         {if (true) throw (ParseException)jjte000;}

  209.       }

  210.       {if (true) throw (Error)jjte000;}

  211.     } finally {

  212.       if (jjtc000) {

  213.         jjtree.closeNodeScope(jjtn000, true);

  214.       }

  215.     }

  216.   }

  217. 

  218.   final public void Identifier() throws ParseException {

  219.  /*@bgen(jjtree) Identifier */

  220.    ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);

  221.    boolean jjtc000 = true;

  222.    jjtree.openNodeScope(jjtn000);Token t;

  223.     try {

  224.       t = jj_consume_token(IDENTIFIER);

  225.       jjtree.closeNodeScope(jjtn000, true);

  226.       jjtc000 = false;

  227.        jjtn000.val = t.image;

  228.     } finally {

  229.       if (jjtc000) {

  230.         jjtree.closeNodeScope(jjtn000, true);

  231.       }

  232.     }

  233.   }

  234. 

  235. /*

  236.  * Expression syntax follows.

  237.  */

  238.   final public void Expression() throws ParseException {

  239.                      /*@bgen(jjtree) Expression */

  240.   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);

  241.   boolean jjtc000 = true;

  242.   jjtree.openNodeScope(jjtn000);

  243.     try {

  244.       if (jj_2_1(2147483647)) {

  245.         Assignment();

  246.       } else {

  247.         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  248.         case INTEGER_LITERAL:

  249.         case FLOAT_LITERAL:

  250.         case 11:

  251.         case 12:

  252.         case 14:

  253.         case 36:

  254.         case 42:

  255.         case 43:

  256.         case 44:

  257.         case 45:

  258.         case 46:

  259.         case 47:

  260.         case IDENTIFIER:

  261.         case STRING_LITERAL:

  262.           ConditionalOrExpression();

  263.           break;

  264.         default:

  265.           jj_la1[3] = jj_gen;

  266.           jj_consume_token(-1);

  267.           throw new ParseException();

  268.         }

  269.       }

  270.     } catch (Throwable jjte000) {

  271.     if (jjtc000) {

  272.       jjtree.clearNodeScope(jjtn000);

  273.       jjtc000 = false;

  274.     } else {

  275.       jjtree.popNode();

  276.     }

  277.     if (jjte000 instanceof RuntimeException) {

  278.       {if (true) throw (RuntimeException)jjte000;}

  279.     }

  280.     if (jjte000 instanceof ParseException) {

  281.       {if (true) throw (ParseException)jjte000;}

  282.     }

  283.     {if (true) throw (Error)jjte000;}

  284.     } finally {

  285.     if (jjtc000) {

  286.       jjtree.closeNodeScope(jjtn000, true);

  287.     }

  288.     }

  289.   }

  290. 

  291.   final public void Assignment() throws ParseException {

  292.  /*@bgen(jjtree) #Assignment( 2) */

  293.   ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);

  294.   boolean jjtc000 = true;

  295.   jjtree.openNodeScope(jjtn000);

  296.     try {

  297.       PrimaryExpression();

  298.       jj_consume_token(15);

  299.       Expression();

  300.     } catch (Throwable jjte000) {

  301.     if (jjtc000) {

  302.       jjtree.clearNodeScope(jjtn000);

  303.       jjtc000 = false;

  304.     } else {

  305.       jjtree.popNode();

  306.     }

  307.     if (jjte000 instanceof RuntimeException) {

  308.       {if (true) throw (RuntimeException)jjte000;}

  309.     }

  310.     if (jjte000 instanceof ParseException) {

  311.       {if (true) throw (ParseException)jjte000;}

  312.     }

  313.     {if (true) throw (Error)jjte000;}

  314.     } finally {

  315.     if (jjtc000) {

  316.       jjtree.closeNodeScope(jjtn000,  2);

  317.     }

  318.     }

  319.   }

  320. 

  321.   final public void ConditionalOrExpression() throws ParseException {

  322.     ConditionalAndExpression();

  323.     label_3:

  324.     while (true) {

  325.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  326.       case 16:

  327.       case 17:

  328.         ;

  329.         break;

  330.       default:

  331.         jj_la1[4] = jj_gen;

  332.         break label_3;

  333.       }

  334.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  335.       case 16:

  336.         jj_consume_token(16);

  337.            ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);

  338.            boolean jjtc001 = true;

  339.            jjtree.openNodeScope(jjtn001);

  340.         try {

  341.           ConditionalAndExpression();

  342.         } catch (Throwable jjte001) {

  343.            if (jjtc001) {

  344.              jjtree.clearNodeScope(jjtn001);

  345.              jjtc001 = false;

  346.            } else {

  347.              jjtree.popNode();

  348.            }

  349.            if (jjte001 instanceof RuntimeException) {

  350.              {if (true) throw (RuntimeException)jjte001;}

  351.            }

  352.            if (jjte001 instanceof ParseException) {

  353.              {if (true) throw (ParseException)jjte001;}

  354.            }

  355.            {if (true) throw (Error)jjte001;}

  356.         } finally {

  357.            if (jjtc001) {

  358.              jjtree.closeNodeScope(jjtn001,  2);

  359.            }

  360.         }

  361.         break;

  362.       case 17:

  363.         jj_consume_token(17);

  364.            ASTOrNode jjtn002 = new ASTOrNode(this, JJTORNODE);

  365.            boolean jjtc002 = true;

  366.            jjtree.openNodeScope(jjtn002);

  367.         try {

  368.           ConditionalAndExpression();

  369.         } catch (Throwable jjte002) {

  370.            if (jjtc002) {

  371.              jjtree.clearNodeScope(jjtn002);

  372.              jjtc002 = false;

  373.            } else {

  374.              jjtree.popNode();

  375.            }

  376.            if (jjte002 instanceof RuntimeException) {

  377.              {if (true) throw (RuntimeException)jjte002;}

  378.            }

  379.            if (jjte002 instanceof ParseException) {

  380.              {if (true) throw (ParseException)jjte002;}

  381.            }

  382.            {if (true) throw (Error)jjte002;}

  383.         } finally {

  384.            if (jjtc002) {

  385.              jjtree.closeNodeScope(jjtn002,  2);

  386.            }

  387.         }

  388.         break;

  389.       default:

  390.         jj_la1[5] = jj_gen;

  391.         jj_consume_token(-1);

  392.         throw new ParseException();

  393.       }

  394.     }

  395.   }

  396. 

  397.   final public void ConditionalAndExpression() throws ParseException {

  398.     InclusiveOrExpression();

  399.     label_4:

  400.     while (true) {

  401.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  402.       case 18:

  403.       case 19:

  404.         ;

  405.         break;

  406.       default:

  407.         jj_la1[6] = jj_gen;

  408.         break label_4;

  409.       }

  410.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  411.       case 18:

  412.         jj_consume_token(18);

  413.            ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);

  414.            boolean jjtc001 = true;

  415.            jjtree.openNodeScope(jjtn001);

  416.         try {

  417.           InclusiveOrExpression();

  418.         } catch (Throwable jjte001) {

  419.            if (jjtc001) {

  420.              jjtree.clearNodeScope(jjtn001);

  421.              jjtc001 = false;

  422.            } else {

  423.              jjtree.popNode();

  424.            }

  425.            if (jjte001 instanceof RuntimeException) {

  426.              {if (true) throw (RuntimeException)jjte001;}

  427.            }

  428.            if (jjte001 instanceof ParseException) {

  429.              {if (true) throw (ParseException)jjte001;}

  430.            }

  431.            {if (true) throw (Error)jjte001;}

  432.         } finally {

  433.            if (jjtc001) {

  434.              jjtree.closeNodeScope(jjtn001,  2);

  435.            }

  436.         }

  437.         break;

  438.       case 19:

  439.         jj_consume_token(19);

  440.             ASTAndNode jjtn002 = new ASTAndNode(this, JJTANDNODE);

  441.             boolean jjtc002 = true;

  442.             jjtree.openNodeScope(jjtn002);

  443.         try {

  444.           InclusiveOrExpression();

  445.         } catch (Throwable jjte002) {

  446.             if (jjtc002) {

  447.               jjtree.clearNodeScope(jjtn002);

  448.               jjtc002 = false;

  449.             } else {

  450.               jjtree.popNode();

  451.             }

  452.             if (jjte002 instanceof RuntimeException) {

  453.               {if (true) throw (RuntimeException)jjte002;}

  454.             }

  455.             if (jjte002 instanceof ParseException) {

  456.               {if (true) throw (ParseException)jjte002;}

  457.             }

  458.             {if (true) throw (Error)jjte002;}

  459.         } finally {

  460.             if (jjtc002) {

  461.               jjtree.closeNodeScope(jjtn002,  2);

  462.             }

  463.         }

  464.         break;

  465.       default:

  466.         jj_la1[7] = jj_gen;

  467.         jj_consume_token(-1);

  468.         throw new ParseException();

  469.       }

  470.     }

  471.   }

  472. 

  473.   final public void InclusiveOrExpression() throws ParseException {

  474.     ExclusiveOrExpression();

  475.     label_5:

  476.     while (true) {

  477.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  478.       case 20:

  479.         ;

  480.         break;

  481.       default:

  482.         jj_la1[8] = jj_gen;

  483.         break label_5;

  484.       }

  485.       jj_consume_token(20);

  486.           ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(this, JJTBITWISEORNODE);

  487.           boolean jjtc001 = true;

  488.           jjtree.openNodeScope(jjtn001);

  489.       try {

  490.         ExclusiveOrExpression();

  491.       } catch (Throwable jjte001) {

  492.           if (jjtc001) {

  493.             jjtree.clearNodeScope(jjtn001);

  494.             jjtc001 = false;

  495.           } else {

  496.             jjtree.popNode();

  497.           }

  498.           if (jjte001 instanceof RuntimeException) {

  499.             {if (true) throw (RuntimeException)jjte001;}

  500.           }

  501.           if (jjte001 instanceof ParseException) {

  502.             {if (true) throw (ParseException)jjte001;}

  503.           }

  504.           {if (true) throw (Error)jjte001;}

  505.       } finally {

  506.           if (jjtc001) {

  507.             jjtree.closeNodeScope(jjtn001,  2);

  508.           }

  509.       }

  510.     }

  511.   }

  512. 

  513.   final public void ExclusiveOrExpression() throws ParseException {

  514.     AndExpression();

  515.     label_6:

  516.     while (true) {

  517.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  518.       case 21:

  519.         ;

  520.         break;

  521.       default:

  522.         jj_la1[9] = jj_gen;

  523.         break label_6;

  524.       }

  525.       jj_consume_token(21);

  526.           ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(this, JJTBITWISEXORNODE);

  527.           boolean jjtc001 = true;

  528.           jjtree.openNodeScope(jjtn001);

  529.       try {

  530.         AndExpression();

  531.       } catch (Throwable jjte001) {

  532.           if (jjtc001) {

  533.             jjtree.clearNodeScope(jjtn001);

  534.             jjtc001 = false;

  535.           } else {

  536.             jjtree.popNode();

  537.           }

  538.           if (jjte001 instanceof RuntimeException) {

  539.             {if (true) throw (RuntimeException)jjte001;}

  540.           }

  541.           if (jjte001 instanceof ParseException) {

  542.             {if (true) throw (ParseException)jjte001;}

  543.           }

  544.           {if (true) throw (Error)jjte001;}

  545.       } finally {

  546.           if (jjtc001) {

  547.             jjtree.closeNodeScope(jjtn001,  2);

  548.           }

  549.       }

  550.     }

  551.   }

  552. 

  553.   final public void AndExpression() throws ParseException {

  554.     EqualityExpression();

  555.     label_7:

  556.     while (true) {

  557.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  558.       case 22:

  559.         ;

  560.         break;

  561.       default:

  562.         jj_la1[10] = jj_gen;

  563.         break label_7;

  564.       }

  565.       jj_consume_token(22);

  566.           ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(this, JJTBITWISEANDNODE);

  567.           boolean jjtc001 = true;

  568.           jjtree.openNodeScope(jjtn001);

  569.       try {

  570.         EqualityExpression();

  571.       } catch (Throwable jjte001) {

  572.           if (jjtc001) {

  573.             jjtree.clearNodeScope(jjtn001);

  574.             jjtc001 = false;

  575.           } else {

  576.             jjtree.popNode();

  577.           }

  578.           if (jjte001 instanceof RuntimeException) {

  579.             {if (true) throw (RuntimeException)jjte001;}

  580.           }

  581.           if (jjte001 instanceof ParseException) {

  582.             {if (true) throw (ParseException)jjte001;}

  583.           }

  584.           {if (true) throw (Error)jjte001;}

  585.       } finally {

  586.           if (jjtc001) {

  587.             jjtree.closeNodeScope(jjtn001,  2);

  588.           }

  589.       }

  590.     }

  591.   }

  592. 

  593.   final public void EqualityExpression() throws ParseException {

  594.     RelationalExpression();

  595.     label_8:

  596.     while (true) {

  597.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  598.       case 23:

  599.       case 24:

  600.       case 25:

  601.       case 26:

  602.         ;

  603.         break;

  604.       default:

  605.         jj_la1[11] = jj_gen;

  606.         break label_8;

  607.       }

  608.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  609.       case 23:

  610.         jj_consume_token(23);

  611.             ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);

  612.             boolean jjtc001 = true;

  613.             jjtree.openNodeScope(jjtn001);

  614.         try {

  615.           RelationalExpression();

  616.         } catch (Throwable jjte001) {

  617.             if (jjtc001) {

  618.               jjtree.clearNodeScope(jjtn001);

  619.               jjtc001 = false;

  620.             } else {

  621.               jjtree.popNode();

  622.             }

  623.             if (jjte001 instanceof RuntimeException) {

  624.               {if (true) throw (RuntimeException)jjte001;}

  625.             }

  626.             if (jjte001 instanceof ParseException) {

  627.               {if (true) throw (ParseException)jjte001;}

  628.             }

  629.             {if (true) throw (Error)jjte001;}

  630.         } finally {

  631.             if (jjtc001) {

  632.               jjtree.closeNodeScope(jjtn001,  2);

  633.             }

  634.         }

  635.         break;

  636.       case 24:

  637.         jj_consume_token(24);

  638.             ASTEQNode jjtn002 = new ASTEQNode(this, JJTEQNODE);

  639.             boolean jjtc002 = true;

  640.             jjtree.openNodeScope(jjtn002);

  641.         try {

  642.           RelationalExpression();

  643.         } catch (Throwable jjte002) {

  644.             if (jjtc002) {

  645.               jjtree.clearNodeScope(jjtn002);

  646.               jjtc002 = false;

  647.             } else {

  648.               jjtree.popNode();

  649.             }

  650.             if (jjte002 instanceof RuntimeException) {

  651.               {if (true) throw (RuntimeException)jjte002;}

  652.             }

  653.             if (jjte002 instanceof ParseException) {

  654.               {if (true) throw (ParseException)jjte002;}

  655.             }

  656.             {if (true) throw (Error)jjte002;}

  657.         } finally {

  658.             if (jjtc002) {

  659.               jjtree.closeNodeScope(jjtn002,  2);

  660.             }

  661.         }

  662.         break;

  663.       case 25:

  664.         jj_consume_token(25);

  665.             ASTNENode jjtn003 = new ASTNENode(this, JJTNENODE);

  666.             boolean jjtc003 = true;

  667.             jjtree.openNodeScope(jjtn003);

  668.         try {

  669.           RelationalExpression();

  670.         } catch (Throwable jjte003) {

  671.             if (jjtc003) {

  672.               jjtree.clearNodeScope(jjtn003);

  673.               jjtc003 = false;

  674.             } else {

  675.               jjtree.popNode();

  676.             }

  677.             if (jjte003 instanceof RuntimeException) {

  678.               {if (true) throw (RuntimeException)jjte003;}

  679.             }

  680.             if (jjte003 instanceof ParseException) {

  681.               {if (true) throw (ParseException)jjte003;}

  682.             }

  683.             {if (true) throw (Error)jjte003;}

  684.         } finally {

  685.             if (jjtc003) {

  686.               jjtree.closeNodeScope(jjtn003,  2);

  687.             }

  688.         }

  689.         break;

  690.       case 26:

  691.         jj_consume_token(26);

  692.             ASTNENode jjtn004 = new ASTNENode(this, JJTNENODE);

  693.             boolean jjtc004 = true;

  694.             jjtree.openNodeScope(jjtn004);

  695.         try {

  696.           RelationalExpression();

  697.         } catch (Throwable jjte004) {

  698.             if (jjtc004) {

  699.               jjtree.clearNodeScope(jjtn004);

  700.               jjtc004 = false;

  701.             } else {

  702.               jjtree.popNode();

  703.             }

  704.             if (jjte004 instanceof RuntimeException) {

  705.               {if (true) throw (RuntimeException)jjte004;}

  706.             }

  707.             if (jjte004 instanceof ParseException) {

  708.               {if (true) throw (ParseException)jjte004;}

  709.             }

  710.             {if (true) throw (Error)jjte004;}

  711.         } finally {

  712.             if (jjtc004) {

  713.               jjtree.closeNodeScope(jjtn004,  2);

  714.             }

  715.         }

  716.         break;

  717.       default:

  718.         jj_la1[12] = jj_gen;

  719.         jj_consume_token(-1);

  720.         throw new ParseException();

  721.       }

  722.     }

  723.   }

  724. 

  725.   final public void RelationalExpression() throws ParseException {

  726.     AdditiveExpression();

  727.     label_9:

  728.     while (true) {

  729.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  730.       case 27:

  731.       case 28:

  732.       case 29:

  733.       case 30:

  734.       case 31:

  735.       case 32:

  736.       case 33:

  737.       case 34:

  738.         ;

  739.         break;

  740.       default:

  741.         jj_la1[13] = jj_gen;

  742.         break label_9;

  743.       }

  744.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  745.       case 27:

  746.         jj_consume_token(27);

  747.           ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);

  748.           boolean jjtc001 = true;

  749.           jjtree.openNodeScope(jjtn001);

  750.         try {

  751.           AdditiveExpression();

  752.         } catch (Throwable jjte001) {

  753.           if (jjtc001) {

  754.             jjtree.clearNodeScope(jjtn001);

  755.             jjtc001 = false;

  756.           } else {

  757.             jjtree.popNode();

  758.           }

  759.           if (jjte001 instanceof RuntimeException) {

  760.             {if (true) throw (RuntimeException)jjte001;}

  761.           }

  762.           if (jjte001 instanceof ParseException) {

  763.             {if (true) throw (ParseException)jjte001;}

  764.           }

  765.           {if (true) throw (Error)jjte001;}

  766.         } finally {

  767.           if (jjtc001) {

  768.             jjtree.closeNodeScope(jjtn001,  2);

  769.           }

  770.         }

  771.         break;

  772.       case 28:

  773.         jj_consume_token(28);

  774.            ASTLTNode jjtn002 = new ASTLTNode(this, JJTLTNODE);

  775.            boolean jjtc002 = true;

  776.            jjtree.openNodeScope(jjtn002);

  777.         try {

  778.           AdditiveExpression();

  779.         } catch (Throwable jjte002) {

  780.            if (jjtc002) {

  781.              jjtree.clearNodeScope(jjtn002);

  782.              jjtc002 = false;

  783.            } else {

  784.              jjtree.popNode();

  785.            }

  786.            if (jjte002 instanceof RuntimeException) {

  787.              {if (true) throw (RuntimeException)jjte002;}

  788.            }

  789.            if (jjte002 instanceof ParseException) {

  790.              {if (true) throw (ParseException)jjte002;}

  791.            }

  792.            {if (true) throw (Error)jjte002;}

  793.         } finally {

  794.            if (jjtc002) {

  795.              jjtree.closeNodeScope(jjtn002,  2);

  796.            }

  797.         }

  798.         break;

  799.       case 29:

  800.         jj_consume_token(29);

  801.           ASTGTNode jjtn003 = new ASTGTNode(this, JJTGTNODE);

  802.           boolean jjtc003 = true;

  803.           jjtree.openNodeScope(jjtn003);

  804.         try {

  805.           AdditiveExpression();

  806.         } catch (Throwable jjte003) {

  807.           if (jjtc003) {

  808.             jjtree.clearNodeScope(jjtn003);

  809.             jjtc003 = false;

  810.           } else {

  811.             jjtree.popNode();

  812.           }

  813.           if (jjte003 instanceof RuntimeException) {

  814.             {if (true) throw (RuntimeException)jjte003;}

  815.           }

  816.           if (jjte003 instanceof ParseException) {

  817.             {if (true) throw (ParseException)jjte003;}

  818.           }

  819.           {if (true) throw (Error)jjte003;}

  820.         } finally {

  821.           if (jjtc003) {

  822.             jjtree.closeNodeScope(jjtn003,  2);

  823.           }

  824.         }

  825.         break;

  826.       case 30:

  827.         jj_consume_token(30);

  828.            ASTGTNode jjtn004 = new ASTGTNode(this, JJTGTNODE);

  829.            boolean jjtc004 = true;

  830.            jjtree.openNodeScope(jjtn004);

  831.         try {

  832.           AdditiveExpression();

  833.         } catch (Throwable jjte004) {

  834.            if (jjtc004) {

  835.              jjtree.clearNodeScope(jjtn004);

  836.              jjtc004 = false;

  837.            } else {

  838.              jjtree.popNode();

  839.            }

  840.            if (jjte004 instanceof RuntimeException) {

  841.              {if (true) throw (RuntimeException)jjte004;}

  842.            }

  843.            if (jjte004 instanceof ParseException) {

  844.              {if (true) throw (ParseException)jjte004;}

  845.            }

  846.            {if (true) throw (Error)jjte004;}

  847.         } finally {

  848.            if (jjtc004) {

  849.              jjtree.closeNodeScope(jjtn004,  2);

  850.            }

  851.         }

  852.         break;

  853.       case 31:

  854.         jj_consume_token(31);

  855.            ASTLENode jjtn005 = new ASTLENode(this, JJTLENODE);

  856.            boolean jjtc005 = true;

  857.            jjtree.openNodeScope(jjtn005);

  858.         try {

  859.           AdditiveExpression();

  860.         } catch (Throwable jjte005) {

  861.            if (jjtc005) {

  862.              jjtree.clearNodeScope(jjtn005);

  863.              jjtc005 = false;

  864.            } else {

  865.              jjtree.popNode();

  866.            }

  867.            if (jjte005 instanceof RuntimeException) {

  868.              {if (true) throw (RuntimeException)jjte005;}

  869.            }

  870.            if (jjte005 instanceof ParseException) {

  871.              {if (true) throw (ParseException)jjte005;}

  872.            }

  873.            {if (true) throw (Error)jjte005;}

  874.         } finally {

  875.            if (jjtc005) {

  876.              jjtree.closeNodeScope(jjtn005,  2);

  877.            }

  878.         }

  879.         break;

  880.       case 32:

  881.         jj_consume_token(32);

  882.            ASTLENode jjtn006 = new ASTLENode(this, JJTLENODE);

  883.            boolean jjtc006 = true;

  884.            jjtree.openNodeScope(jjtn006);

  885.         try {

  886.           AdditiveExpression();

  887.         } catch (Throwable jjte006) {

  888.            if (jjtc006) {

  889.              jjtree.clearNodeScope(jjtn006);

  890.              jjtc006 = false;

  891.            } else {

  892.              jjtree.popNode();

  893.            }

  894.            if (jjte006 instanceof RuntimeException) {

  895.              {if (true) throw (RuntimeException)jjte006;}

  896.            }

  897.            if (jjte006 instanceof ParseException) {

  898.              {if (true) throw (ParseException)jjte006;}

  899.            }

  900.            {if (true) throw (Error)jjte006;}

  901.         } finally {

  902.            if (jjtc006) {

  903.              jjtree.closeNodeScope(jjtn006,  2);

  904.            }

  905.         }

  906.         break;

  907.       case 33:

  908.         jj_consume_token(33);

  909.            ASTGENode jjtn007 = new ASTGENode(this, JJTGENODE);

  910.            boolean jjtc007 = true;

  911.            jjtree.openNodeScope(jjtn007);

  912.         try {

  913.           AdditiveExpression();

  914.         } catch (Throwable jjte007) {

  915.            if (jjtc007) {

  916.              jjtree.clearNodeScope(jjtn007);

  917.              jjtc007 = false;

  918.            } else {

  919.              jjtree.popNode();

  920.            }

  921.            if (jjte007 instanceof RuntimeException) {

  922.              {if (true) throw (RuntimeException)jjte007;}

  923.            }

  924.            if (jjte007 instanceof ParseException) {

  925.              {if (true) throw (ParseException)jjte007;}

  926.            }

  927.            {if (true) throw (Error)jjte007;}

  928.         } finally {

  929.            if (jjtc007) {

  930.              jjtree.closeNodeScope(jjtn007,  2);

  931.            }

  932.         }

  933.         break;

  934.       case 34:

  935.         jj_consume_token(34);

  936.            ASTGENode jjtn008 = new ASTGENode(this, JJTGENODE);

  937.            boolean jjtc008 = true;

  938.            jjtree.openNodeScope(jjtn008);

  939.         try {

  940.           AdditiveExpression();

  941.         } catch (Throwable jjte008) {

  942.            if (jjtc008) {

  943.              jjtree.clearNodeScope(jjtn008);

  944.              jjtc008 = false;

  945.            } else {

  946.              jjtree.popNode();

  947.            }

  948.            if (jjte008 instanceof RuntimeException) {

  949.              {if (true) throw (RuntimeException)jjte008;}

  950.            }

  951.            if (jjte008 instanceof ParseException) {

  952.              {if (true) throw (ParseException)jjte008;}

  953.            }

  954.            {if (true) throw (Error)jjte008;}

  955.         } finally {

  956.            if (jjtc008) {

  957.              jjtree.closeNodeScope(jjtn008,  2);

  958.            }

  959.         }

  960.         break;

  961.       default:

  962.         jj_la1[14] = jj_gen;

  963.         jj_consume_token(-1);

  964.         throw new ParseException();

  965.       }

  966.     }

  967.   }

  968. 

  969.   final public void AdditiveExpression() throws ParseException {

  970.     MultiplicativeExpression();

  971.     label_10:

  972.     while (true) {

  973.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  974.       case 35:

  975.       case 36:

  976.         ;

  977.         break;

  978.       default:

  979.         jj_la1[15] = jj_gen;

  980.         break label_10;

  981.       }

  982.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  983.       case 35:

  984.         jj_consume_token(35);

  985.           ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);

  986.           boolean jjtc001 = true;

  987.           jjtree.openNodeScope(jjtn001);

  988.         try {

  989.           MultiplicativeExpression();

  990.         } catch (Throwable jjte001) {

  991.           if (jjtc001) {

  992.             jjtree.clearNodeScope(jjtn001);

  993.             jjtc001 = false;

  994.           } else {

  995.             jjtree.popNode();

  996.           }

  997.           if (jjte001 instanceof RuntimeException) {

  998.             {if (true) throw (RuntimeException)jjte001;}

  999.           }

  1000.           if (jjte001 instanceof ParseException) {

  1001.             {if (true) throw (ParseException)jjte001;}

  1002.           }

  1003.           {if (true) throw (Error)jjte001;}

  1004.         } finally {

  1005.           if (jjtc001) {

  1006.             jjtree.closeNodeScope(jjtn001,  2);

  1007.           }

  1008.         }

  1009.         break;

  1010.       case 36:

  1011.         jj_consume_token(36);

  1012.           ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);

  1013.           boolean jjtc002 = true;

  1014.           jjtree.openNodeScope(jjtn002);

  1015.         try {

  1016.           MultiplicativeExpression();

  1017.         } catch (Throwable jjte002) {

  1018.           if (jjtc002) {

  1019.             jjtree.clearNodeScope(jjtn002);

  1020.             jjtc002 = false;

  1021.           } else {

  1022.             jjtree.popNode();

  1023.           }

  1024.           if (jjte002 instanceof RuntimeException) {

  1025.             {if (true) throw (RuntimeException)jjte002;}

  1026.           }

  1027.           if (jjte002 instanceof ParseException) {

  1028.             {if (true) throw (ParseException)jjte002;}

  1029.           }

  1030.           {if (true) throw (Error)jjte002;}

  1031.         } finally {

  1032.           if (jjtc002) {

  1033.             jjtree.closeNodeScope(jjtn002,  2);

  1034.           }

  1035.         }

  1036.         break;

  1037.       default:

  1038.         jj_la1[16] = jj_gen;

  1039.         jj_consume_token(-1);

  1040.         throw new ParseException();

  1041.       }

  1042.     }

  1043.   }

  1044. 

  1045.   final public void MultiplicativeExpression() throws ParseException {

  1046.     UnaryExpression();

  1047.     label_11:

  1048.     while (true) {

  1049.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  1050.       case 37:

  1051.       case 38:

  1052.       case 39:

  1053.       case 40:

  1054.       case 41:

  1055.         ;

  1056.         break;

  1057.       default:

  1058.         jj_la1[17] = jj_gen;

  1059.         break label_11;

  1060.       }

  1061.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  1062.       case 37:

  1063.         jj_consume_token(37);

  1064.           ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);

  1065.           boolean jjtc001 = true;

  1066.           jjtree.openNodeScope(jjtn001);

  1067.         try {

  1068.           UnaryExpression();

  1069.         } catch (Throwable jjte001) {

  1070.           if (jjtc001) {

  1071.             jjtree.clearNodeScope(jjtn001);

  1072.             jjtc001 = false;

  1073.           } else {

  1074.             jjtree.popNode();

  1075.           }

  1076.           if (jjte001 instanceof RuntimeException) {

  1077.             {if (true) throw (RuntimeException)jjte001;}

  1078.           }

  1079.           if (jjte001 instanceof ParseException) {

  1080.             {if (true) throw (ParseException)jjte001;}

  1081.           }

  1082.           {if (true) throw (Error)jjte001;}

  1083.         } finally {

  1084.           if (jjtc001) {

  1085.             jjtree.closeNodeScope(jjtn001,  2);

  1086.           }

  1087.         }

  1088.         break;

  1089.       case 38:

  1090.         jj_consume_token(38);

  1091.           ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);

  1092.           boolean jjtc002 = true;

  1093.           jjtree.openNodeScope(jjtn002);

  1094.         try {

  1095.           UnaryExpression();

  1096.         } catch (Throwable jjte002) {

  1097.           if (jjtc002) {

  1098.             jjtree.clearNodeScope(jjtn002);

  1099.             jjtc002 = false;

  1100.           } else {

  1101.             jjtree.popNode();

  1102.           }

  1103.           if (jjte002 instanceof RuntimeException) {

  1104.             {if (true) throw (RuntimeException)jjte002;}

  1105.           }

  1106.           if (jjte002 instanceof ParseException) {

  1107.             {if (true) throw (ParseException)jjte002;}

  1108.           }

  1109.           {if (true) throw (Error)jjte002;}

  1110.         } finally {

  1111.           if (jjtc002) {

  1112.             jjtree.closeNodeScope(jjtn002,  2);

  1113.           }

  1114.         }

  1115.         break;

  1116.       case 39:

  1117.         jj_consume_token(39);

  1118.             ASTDivNode jjtn003 = new ASTDivNode(this, JJTDIVNODE);

  1119.             boolean jjtc003 = true;

  1120.             jjtree.openNodeScope(jjtn003);

  1121.         try {

  1122.           UnaryExpression();

  1123.         } catch (Throwable jjte003) {

  1124.             if (jjtc003) {

  1125.               jjtree.clearNodeScope(jjtn003);

  1126.               jjtc003 = false;

  1127.             } else {

  1128.               jjtree.popNode();

  1129.             }

  1130.             if (jjte003 instanceof RuntimeException) {

  1131.               {if (true) throw (RuntimeException)jjte003;}

  1132.             }

  1133.             if (jjte003 instanceof ParseException) {

  1134.               {if (true) throw (ParseException)jjte003;}

  1135.             }

  1136.             {if (true) throw (Error)jjte003;}

  1137.         } finally {

  1138.             if (jjtc003) {

  1139.               jjtree.closeNodeScope(jjtn003,  2);

  1140.             }

  1141.         }

  1142.         break;

  1143.       case 40:

  1144.         jj_consume_token(40);

  1145.           ASTModNode jjtn004 = new ASTModNode(this, JJTMODNODE);

  1146.           boolean jjtc004 = true;

  1147.           jjtree.openNodeScope(jjtn004);

  1148.         try {

  1149.           UnaryExpression();

  1150.         } catch (Throwable jjte004) {

  1151.           if (jjtc004) {

  1152.             jjtree.clearNodeScope(jjtn004);

  1153.             jjtc004 = false;

  1154.           } else {

  1155.             jjtree.popNode();

  1156.           }

  1157.           if (jjte004 instanceof RuntimeException) {

  1158.             {if (true) throw (RuntimeException)jjte004;}

  1159.           }

  1160.           if (jjte004 instanceof ParseException) {

  1161.             {if (true) throw (ParseException)jjte004;}

  1162.           }

  1163.           {if (true) throw (Error)jjte004;}

  1164.         } finally {

  1165.           if (jjtc004) {

  1166.             jjtree.closeNodeScope(jjtn004,  2);

  1167.           }

  1168.         }

  1169.         break;

  1170.       case 41:

  1171.         jj_consume_token(41);

  1172.             ASTModNode jjtn005 = new ASTModNode(this, JJTMODNODE);

  1173.             boolean jjtc005 = true;

  1174.             jjtree.openNodeScope(jjtn005);

  1175.         try {

  1176.           UnaryExpression();

  1177.         } catch (Throwable jjte005) {

  1178.             if (jjtc005) {

  1179.               jjtree.clearNodeScope(jjtn005);

  1180.               jjtc005 = false;

  1181.             } else {

  1182.               jjtree.popNode();

  1183.             }

  1184.             if (jjte005 instanceof RuntimeException) {

  1185.               {if (true) throw (RuntimeException)jjte005;}

  1186.             }

  1187.             if (jjte005 instanceof ParseException) {

  1188.               {if (true) throw (ParseException)jjte005;}

  1189.             }

  1190.             {if (true) throw (Error)jjte005;}

  1191.         } finally {

  1192.             if (jjtc005) {

  1193.               jjtree.closeNodeScope(jjtn005,  2);

  1194.             }

  1195.         }

  1196.         break;

  1197.       default:

  1198.         jj_la1[18] = jj_gen;

  1199.         jj_consume_token(-1);

  1200.         throw new ParseException();

  1201.       }

  1202.     }

  1203.   }

  1204. 

  1205.   final public void UnaryExpression() throws ParseException {

  1206.     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  1207.     case 36:

  1208.       jj_consume_token(36);

  1209.         ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(this, JJTUNARYMINUSNODE);

  1210.         boolean jjtc001 = true;

  1211.         jjtree.openNodeScope(jjtn001);

  1212.       try {

  1213.         UnaryExpression();

  1214.       } catch (Throwable jjte001) {

  1215.         if (jjtc001) {

  1216.           jjtree.clearNodeScope(jjtn001);

  1217.           jjtc001 = false;

  1218.         } else {

  1219.           jjtree.popNode();

  1220.         }

  1221.         if (jjte001 instanceof RuntimeException) {

  1222.           {if (true) throw (RuntimeException)jjte001;}

  1223.         }

  1224.         if (jjte001 instanceof ParseException) {

  1225.           {if (true) throw (ParseException)jjte001;}

  1226.         }

  1227.         {if (true) throw (Error)jjte001;}

  1228.       } finally {

  1229.         if (jjtc001) {

  1230.           jjtree.closeNodeScope(jjtn001,  1);

  1231.         }

  1232.       }

  1233.       break;

  1234.     case 42:

  1235.       jj_consume_token(42);

  1236.         ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(this, JJTBITWISECOMPLNODE);

  1237.         boolean jjtc002 = true;

  1238.         jjtree.openNodeScope(jjtn002);

  1239.       try {

  1240.         UnaryExpression();

  1241.       } catch (Throwable jjte002) {

  1242.         if (jjtc002) {

  1243.           jjtree.clearNodeScope(jjtn002);

  1244.           jjtc002 = false;

  1245.         } else {

  1246.           jjtree.popNode();

  1247.         }

  1248.         if (jjte002 instanceof RuntimeException) {

  1249.           {if (true) throw (RuntimeException)jjte002;}

  1250.         }

  1251.         if (jjte002 instanceof ParseException) {

  1252.           {if (true) throw (ParseException)jjte002;}

  1253.         }

  1254.         {if (true) throw (Error)jjte002;}

  1255.       } finally {

  1256.         if (jjtc002) {

  1257.           jjtree.closeNodeScope(jjtn002,  1);

  1258.         }

  1259.       }

  1260.       break;

  1261.     case 43:

  1262.       jj_consume_token(43);

  1263.         ASTNotNode jjtn003 = new ASTNotNode(this, JJTNOTNODE);

  1264.         boolean jjtc003 = true;

  1265.         jjtree.openNodeScope(jjtn003);

  1266.       try {

  1267.         UnaryExpression();

  1268.       } catch (Throwable jjte003) {

  1269.         if (jjtc003) {

  1270.           jjtree.clearNodeScope(jjtn003);

  1271.           jjtc003 = false;

  1272.         } else {

  1273.           jjtree.popNode();

  1274.         }

  1275.         if (jjte003 instanceof RuntimeException) {

  1276.           {if (true) throw (RuntimeException)jjte003;}

  1277.         }

  1278.         if (jjte003 instanceof ParseException) {

  1279.           {if (true) throw (ParseException)jjte003;}

  1280.         }

  1281.         {if (true) throw (Error)jjte003;}

  1282.       } finally {

  1283.         if (jjtc003) {

  1284.           jjtree.closeNodeScope(jjtn003,  1);

  1285.         }

  1286.       }

  1287.       break;

  1288.     case 44:

  1289.       jj_consume_token(44);

  1290.           ASTNotNode jjtn004 = new ASTNotNode(this, JJTNOTNODE);

  1291.           boolean jjtc004 = true;

  1292.           jjtree.openNodeScope(jjtn004);

  1293.       try {

  1294.         UnaryExpression();

  1295.       } catch (Throwable jjte004) {

  1296.           if (jjtc004) {

  1297.             jjtree.clearNodeScope(jjtn004);

  1298.             jjtc004 = false;

  1299.           } else {

  1300.             jjtree.popNode();

  1301.           }

  1302.           if (jjte004 instanceof RuntimeException) {

  1303.             {if (true) throw (RuntimeException)jjte004;}

  1304.           }

  1305.           if (jjte004 instanceof ParseException) {

  1306.             {if (true) throw (ParseException)jjte004;}

  1307.           }

  1308.           {if (true) throw (Error)jjte004;}

  1309.       } finally {

  1310.           if (jjtc004) {

  1311.             jjtree.closeNodeScope(jjtn004,  1);

  1312.           }

  1313.       }

  1314.       break;

  1315.     case INTEGER_LITERAL:

  1316.     case FLOAT_LITERAL:

  1317.     case 11:

  1318.     case 12:

  1319.     case 14:

  1320.     case 45:

  1321.     case 46:

  1322.     case 47:

  1323.     case IDENTIFIER:

  1324.     case STRING_LITERAL:

  1325.       PrimaryExpression();

  1326.       break;

  1327.     default:

  1328.       jj_la1[19] = jj_gen;

  1329.       jj_consume_token(-1);

  1330.       throw new ParseException();

  1331.     }

  1332.   }

  1333. 

  1334.   final public void PrimaryExpression() throws ParseException {

  1335.     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  1336.     case INTEGER_LITERAL:

  1337.     case FLOAT_LITERAL:

  1338.     case 45:

  1339.     case 46:

  1340.     case 47:

  1341.     case STRING_LITERAL:

  1342.       Literal();

  1343.       break;

  1344.     case IDENTIFIER:

  1345.       Reference();

  1346.       break;

  1347.     case 12:

  1348.       jj_consume_token(12);

  1349.       Expression();

  1350.       jj_consume_token(13);

  1351.