0001 /*@bgen(jjtree) Generated By:JJTree: Do not edit this line. JavaScript.jj */
0002 /*@egen*/
0003 /*
0004  *  Descripter 1.0 - Java Script Engines
0005  *  Copyright (C) 2010-2015  Jianjun Liu (J.J.Liu)
0006  *  
0007  *  This program is free software: you can redistribute it and/or modify
0008  *  it under the terms of the GNU Affero General Public License as published by
0009  *  the Free Software Foundation, either version 3 of the License, or
0010  *  (at your option) any later version.
0011  *  
0012  *  This program is distributed in the hope that it will be useful,
0013  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
0014  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0015  *  GNU Affero General Public License for more details.
0016  *  
0017  *  You should have received a copy of the GNU Affero General Public License
0018  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
0019  */
0020 
0021 options {
0022                             
0023     FORCE_LA_CHECK = false;
0024     JDK_VERSION = "1.6";
0025     JAVA_UNICODE_ESCAPE = true;
0026     UNICODE_INPUT = true;
0027                  
0028                                 
0029                              
0030                                              
0031                          
0032                            
0033                             
0034     STATIC = false;
0035                    
0036                                  
0037                                    
0038                            
0039 }
0040 
0041 PARSER_BEGIN(JSParser)
0042 
0043 package org.descripter.js.parse;
0044 
0045 public class JSParser/*@bgen(jjtree)*/implements JSParserTreeConstants/*@egen*/
0046 {/*@bgen(jjtree)*/
0047   protected JJTJSParserState jjtree = new JJTJSParserState();
0048 
0049 /*@egen*/
0050     void jjtreeOpenNodeScope(Node n) {
0051         ((AbstractNode)n).firstToken = getToken(1);
0052     }
0053 
0054     void jjtreeCloseNodeScope(Node n) {
0055         ((AbstractNode)n).lastToken = getToken(0);
0056     }
0057 }
0058 PARSER_END(JSParser)
0059 
0060 /*************************************
0061  * ECMAScript Language Specification *
0062  *************************************/
0063 
0064 /* ECMA-262 5.1 Edition / June 2011 - Section 7.2 : White Space */
0065 
0066 SPECIAL_TOKEN :
0067 {
0068     <TAB: " " | "\t" > /* TAB */
0069 |   <VT: "\u000b" >         /* Vertical Tab */
0070 |   <FF: "" | "\f">   /* Form Feed */
0071 |   <SP: " " | " " >   /* Space */
0072 |   <NBSP: "\u00a0" >       /* No-break space */
0073 |   <BOM: "\ufeff" >        /* Byte Order Mark */
0074 |   <USP:                   /* Other Unicode space seperator */
0075         ["\u1680"] 
0076     |   ["\u180e"] 
0077     |   ["\u2000"] 
0078     |   ["\u2001"] 
0079     |   ["\u2002"] 
0080     |   ["\u2003"] 
0081     |   ["\u2004"] 
0082     |   ["\u2005"] 
0083     |   ["\u2006"] 
0084     |   ["\u2007"]
0085     |   ["\u2008"] 
0086     |   ["\u2009"] 
0087     |   ["\u200a"] 
0088     |   ["\u200b"]
0089     |   ["\u202f"]
0090     |   ["\u205f"]
0091     |   ["\u3000"]
0092     >
0093 }
0094 
0095 /* ECMA-262 5.1 Edition / June 2011 - Section 7.3 : Line Terminators */
0096 
0097 SPECIAL_TOKEN :
0098 {
0099     < LF: "\n" >     /* Line Feed */
0100 |   < CR: "\r" >     /* Carriage Return */
0101 |   < LS: "\u2028" > /* Line separator */
0102 |   < PS: "\u2029" > /* Paragraph separator */
0103 }
0104 
0105 /* ECMA-262 5.1 Edition / June 2011 - Section 7.4 : Comments */
0106 
0107 MORE :
0108 {
0109     "//" : IN_SINGLE_LINE_COMMENT
0110 |   "/*" : IN_MULTI_LINE_COMMENT
0111 }
0112 
0113 <IN_SINGLE_LINE_COMMENT> SPECIAL_TOKEN :
0114 {
0115     <SINGLE_LINE_COMMENT:
0116         (~["\n","\r","\u2028","\u2029"])* ("\n" | "\r" | "\r\n" | "\u2028" | "\u2029")?
0117     > : DEFAULT
0118 }
0119 
0120 <IN_MULTI_LINE_COMMENT> SPECIAL_TOKEN :
0121 {
0122     <MULTI_LINE_COMMENT: "*/" > : DEFAULT
0123 }
0124 
0125 <IN_SINGLE_LINE_COMMENT,IN_MULTI_LINE_COMMENT> MORE :
0126 {
0127     < ~[] >
0128 }
0129 
0130 /* ECMA-262 5.1 Edition / June 2011 - Section 7.6.1.1: Keywords */
0131 
0132 TOKEN :
0133 {
0134   < BREAK: "break" >       | < DO: "do" >             | < INSTANCEOF: "instanceof" > | < TYPEOF: "typeof" >
0135 | < CASE: "case" >         | < ELSE: "else" >         | < NEW: "new" >               | < VAR: "var" >
0136 | < CATCH: "catch" >       | < FINALLY: "finally" >   | < RETURN: "return" >         | < VOID: "void" >
0137 | < CONTINUE: "continue" > | < FOR: "for" >           | < SWITCH: "switch" >         | < WHILE: "while" >
0138 | < DEBUGGER: "debugger" > | < FUNCTION: "function" > | < THIS: "this" >             | < WITH: "with" >
0139 | < DEFAULT_: "default" >  | < IF: "if" >             | < THROW: "throw" >
0140 | < DELETE: "delete" >     | < IN: "in" >             | < TRY: "try" >
0141 }
0142 
0143 /* ECMA-262 5.1 Edition / June 2011 - Section 7.7: Punctuators */
0144 
0145 TOKEN :
0146 {
0147   < LBRACE: "{" > | < RBRACE: "}" >    | < LPAREN: "(" > | < RPAREN: ")" > | < LBRACKET: "[" > | < RBRACKET: "]" >
0148 | < DOT: "." >    | < SEMICOLON: ";" > | < COMMA: "," >  | < LT: "<" >     | < GT: ">" >       | < LTE: "<=" >
0149 | < GTE: ">=" >   | < EQ: "==" >       | < NE: "!=" >    | < EQS: "===" >  | < NEQS: "!==" >
0150 | < PLUS: "+" >   | < MINUS: "-" >     | < MUL: "*" >    | < MOD: "%" >    | < INC: "++" >     | < DEC: "--" >
0151 | < SHL: "<<" >   | < SHR: ">>" >      | < SHRU: ">>>" > | < AND: "&" >    | < OR: "|" >       | < XOR: "^" >
0152 | < BNOT: "!" >   | < NOT: "~" >       | < BAND: "&&" >  | < BOR: "||" >   | < QUEST: "?" >    | < COLON: ":" >
0153 | < ASSIGN: "=" > | < AADD: "+=" >     | < ASUB: "-=" >  | < AMUL: "*=" >  | < AMOD: "%=" >    | < ASHL: "<<=" >
0154 | < ASHR: ">>=" > | < ASHRU: ">>>=" >  | < AAND: "&=" >  | < AOR: "|=" >   | < AXOR: "^=" >
0155 | < DIV: "/" >    | < ADIV: "/=" >
0156 }
0157 
0158 /* ECMA-262 5.1 Edition / June 2011 - Section 7.8: Literals */
0159 
0160 void Literal()          :
0161 {/*@bgen(jjtree) Literal */
0162         ECMALiteral jjtn000 = new ECMALiteral(this, JJTLITERAL);
0163         boolean jjtc000 = true;
0164         jjtree.openNodeScope(jjtn000);
0165         jjtreeOpenNodeScope(jjtn000);
0166 /*@egen*/
0167     Token t;
0168 }
0169 {/*@bgen(jjtree) Literal */
0170 try {
0171 /*@egen*/
0172 (
0173     t = <DECIMAL_LITERAL>
0174 |   t = <HEX_INTEGER_LITERAL>
0175 |   t = <STRING_LITERAL>
0176 |   t = <BOOLEAN_LITERAL>
0177 |   t = <NULL_LITERAL>
0178 |   t = <REGULAR_EXPRESSION_LITERAL>
0179 )/*@bgen(jjtree)*/
0180         {
0181           jjtree.closeNodeScope(jjtn000, true);
0182           jjtc000 = false;
0183           jjtreeCloseNodeScope(jjtn000);
0184         }
0185 /*@egen*/   {
0186         jjtn000.jjtSetValue(t.image);
0187     }/*@bgen(jjtree)*/
0188 } finally {
0189   if (jjtc000) {
0190     jjtree.closeNodeScope(jjtn000, true);
0191     jjtreeCloseNodeScope(jjtn000);
0192   }
0193 }
0194 /*@egen*/
0195 }
0196 
0197 /* ECMA-262 5.1 Edition / June 2011 - Section 7.8.1: NULL Literals */
0198 
0199 TOKEN:
0200 { 
0201     < NULL_LITERAL: "null" >
0202 }
0203 
0204 /* ECMA-262 5.1 Edition / June 2011 - Section 7.8.2: Boolean Literals */
0205 
0206 TOKEN:
0207 { 
0208     < BOOLEAN_LITERAL: "true" | "false" >
0209 }
0210 
0211 /* ECMA-262 5.1 Edition / June 2011 - Section 7.8.3: Numeric Literals */
0212 
0213 TOKEN:
0214 { 
0215     < DECIMAL_LITERAL :
0216         < DECIMAL_INTEGER_LITERAL > "." (< DECIMAL_DIGITS >)? (< EXPONENT_PART >)?
0217     |   "." < DECIMAL_DIGITS > (< EXPONENT_PART >)?
0218     |       < DECIMAL_INTEGER_LITERAL > (< EXPONENT_PART >)? 
0219     > 
0220 |   < DECIMAL_INTEGER_LITERAL: "0" | < NON_ZERO_DIGIT > (< DECIMAL_DIGITS >)?>
0221 |   < DECIMAL_DIGITS: (< DECIMAL_DIGIT >)+ >
0222 |   < DECIMAL_DIGIT: ["0"-"9"] >
0223 |   < #NON_ZERO_DIGIT: ["1"-"9"] >
0224 |   < #EXPONENT_PART: < EXPONENT_INDICATOR > < SIGNED_INTEGER > >
0225 |   < #EXPONENT_INDICATOR: ["e", "E"] >
0226 |   < #SIGNED_INTEGER: (["+", "-"])? < DECIMAL_DIGITS > >
0227 |   < HEX_INTEGER_LITERAL: "0" ["x","X"] (< HEX_DIGIT >)+ >
0228 }
0229 
0230 /* ECMA-262 5.1 Edition / June 2011 - Section 7.8.4: String Literals */
0231 
0232 TOKEN:
0233 {
0234     < STRING_LITERAL:
0235         "\"" (< DOUBLE_STRING_CHARACTERS >)? "\""
0236     |   "'"  (< SINGLE_STRING_CHARACTERS >)? "'"
0237     >
0238 |   < #DOUBLE_STRING_CHARACTERS: (<DOUBLE_STRING_CHARACTER>)* >
0239 |   < #SINGLE_STRING_CHARACTERS: (<SINGLE_STRING_CHARACTER>)* >
0240 |   < #DOUBLE_STRING_CHARACTER:
0241         (~["\"","\\","\n","\r","\u2028","\u2029"])*
0242     |   "\\" < ESCAPE_SEQUENCE >
0243     |   < LINE_CONTINUATION >
0244     >
0245 |   < #SINGLE_STRING_CHARACTER:
0246         (~["'","\\","\n","\r","\u2028","\u2029"])
0247     |   "\\" <ESCAPE_SEQUENCE>
0248     |   < LINE_CONTINUATION >
0249     > 
0250 |   < #LINE_CONTINUATION: "\\" ("\n" | "\r" | "\r\n" | "\u2028" | "\u2029") >
0251 |   < #ESCAPE_SEQUENCE:
0252         <CHARACTER_ESCAPE_SEQUENCE>
0253     |   "0" 
0254     |   <HEX_ESCAPE_SEQUENCE>
0255     |   <UNICODE_ESCAPE_SEQUENCE>
0256     >
0257 |   < #CHARACTER_ESCAPE_SEQUENCE:
0258         <SINGLE_ESCAPE_CHARACTER> | <NON_ESCAPE_CHARACTER>
0259     >
0260 |   < #SINGLE_ESCAPE_CHARACTER: ["'", "\"", "\\", "b", "f", "n", "r", "t", "v"] >
0261 |   < #NON_ESCAPE_CHARACTER: 
0262         ~["'", "\"", "\\", "b", "f", "n", "r", "t", "v"]
0263     |   ~["\n", "\r", "\u2028", "\u2029"]
0264     |   ~["0"-"9"]
0265     |   ~["x", "u"]
0266     >
0267 |   < HEX_ESCAPE_SEQUENCE: "x" < HEX_DIGIT > < HEX_DIGIT > >
0268 }
0269 
0270 /* ECMA-262 5.1 Edition / June 2011 - Section 11.1: Primary Expressions */
0271 
0272 void PrimaryExpression()       :
0273 {}
0274 {
0275     LOOKAHEAD("this")/*@bgen(jjtree) ThisReference */
0276                           {
0277                             ECMAThisReference jjtn001 = new ECMAThisReference(this, JJTTHISREFERENCE);
0278                             boolean jjtc001 = true;
0279                             jjtree.openNodeScope(jjtn001);
0280                             jjtreeOpenNodeScope(jjtn001);
0281                           }
0282                           try {
0283 /*@egen*/ "this"/*@bgen(jjtree)*/
0284                           } finally {
0285                             if (jjtc001) {
0286                               jjtree.closeNodeScope(jjtn001, true);
0287                               jjtreeCloseNodeScope(jjtn001);
0288                             }
0289                           }
0290 /*@egen*/               
0291 |   LOOKAHEAD("{") ObjectLiteral()
0292 |   LOOKAHEAD("(")/*@bgen(jjtree) Group */
0293                        {
0294                          ECMAGroup jjtn002 = new ECMAGroup(this, JJTGROUP);
0295                          boolean jjtc002 = true;
0296                          jjtree.openNodeScope(jjtn002);
0297                          jjtreeOpenNodeScope(jjtn002);
0298                        }
0299                        try {
0300 /*@egen*/ ( "(" Expression() ")" )/*@bgen(jjtree)*/
0301                        } catch (Throwable jjte002) {
0302                          if (jjtc002) {
0303                            jjtree.clearNodeScope(jjtn002);
0304                            jjtc002 = false;
0305                          } else {
0306                            jjtree.popNode();
0307                          }
0308                          if (jjte002 instanceof RuntimeException) {
0309                            throw (RuntimeException)jjte002;
0310                          }
0311                          if (jjte002 instanceof ParseException) {
0312                            throw (ParseException)jjte002;
0313                          }
0314                          throw (Error)jjte002;
0315                        } finally {
0316                          if (jjtc002) {
0317                            jjtree.closeNodeScope(jjtn002, true);
0318                            jjtreeCloseNodeScope(jjtn002);
0319                          }
0320                        }
0321 /*@egen*/       
0322 |   LOOKAHEAD(Identifier()) Identifier()
0323 |   LOOKAHEAD("[") ArrayLiteral()
0324 |   LOOKAHEAD(2) Literal() 
0325 }
0326 
0327 /* ECMA-262 5.1 Edition / June 2011 - Section 11.1.4: Array Initialiser */
0328 
0329 void ArrayLiteral()               : 
0330 {/*@bgen(jjtree) ArrayLiteral */
0331   ECMAArrayLiteral jjtn000 = new ECMAArrayLiteral(this, JJTARRAYLITERAL);
0332   boolean jjtc000 = true;
0333   jjtree.openNodeScope(jjtn000);
0334   jjtreeOpenNodeScope(jjtn000);
0335 /*@egen*/}
0336 {/*@bgen(jjtree) ArrayLiteral */
0337         try {
0338 /*@egen*/
0339     "[" (
0340         LOOKAHEAD(2) ( Elision() )? "]" 
0341     |   LOOKAHEAD(ElementList() Elision()) ElementList() Elision() "]" 
0342     |   ( ElementList() )? "]" 
0343     )/*@bgen(jjtree)*/
0344         } catch (Throwable jjte000) {
0345           if (jjtc000) {
0346             jjtree.clearNodeScope(jjtn000);
0347             jjtc000 = false;
0348           } else {
0349             jjtree.popNode();
0350           }
0351           if (jjte000 instanceof RuntimeException) {
0352             throw (RuntimeException)jjte000;
0353           }
0354           if (jjte000 instanceof ParseException) {
0355             throw (ParseException)jjte000;
0356           }
0357           throw (Error)jjte000;
0358         } finally {
0359           if (jjtc000) {
0360             jjtree.closeNodeScope(jjtn000, true);
0361             jjtreeCloseNodeScope(jjtn000);
0362           }
0363         }
0364 /*@egen*/
0365 }        
0366 
0367 void ElementList()       :
0368 {}
0369 {
0370     ( Elision() )? AssignmentExpression() (
0371         LOOKAHEAD(Elision() AssignmentExpression()) Elision()  AssignmentExpression()
0372     )*
0373 }
0374 
0375 void Elision()       :
0376 {}
0377 {
0378     (",")+
0379 }
0380 
0381 /* ECMA-262 5.1 Edition / June 2011 - Section 11.1.5: Object Initialiser */
0382 
0383 void ObjectLiteral()                :
0384 {/*@bgen(jjtree) ObjectLiteral */
0385   ECMAObjectLiteral jjtn000 = new ECMAObjectLiteral(this, JJTOBJECTLITERAL);
0386   boolean jjtc000 = true;
0387   jjtree.openNodeScope(jjtn000);
0388   jjtreeOpenNodeScope(jjtn000);
0389 /*@egen*/}
0390 {/*@bgen(jjtree) ObjectLiteral */
0391         try {
0392 /*@egen*/
0393     "{" ( PropertyNameAndValueList() )? "}"/*@bgen(jjtree)*/
0394         } catch (Throwable jjte000) {
0395           if (jjtc000) {
0396             jjtree.clearNodeScope(jjtn000);
0397             jjtc000 = false;
0398           } else {
0399             jjtree.popNode();
0400           }
0401           if (jjte000 instanceof RuntimeException) {
0402             throw (RuntimeException)jjte000;
0403           }
0404           if (jjte000 instanceof ParseException) {
0405             throw (ParseException)jjte000;
0406           }
0407           throw (Error)jjte000;
0408         } finally {
0409           if (jjtc000) {
0410             jjtree.closeNodeScope(jjtn000, true);
0411             jjtreeCloseNodeScope(jjtn000);
0412           }
0413         }
0414 /*@egen*/
0415 }
0416 
0417 void PropertyNameAndValueList()       :
0418 {}
0419 {
0420     PropertyAssignment() ( LOOKAHEAD( "," PropertyAssignment()) "," PropertyAssignment() | "," )* 
0421 }
0422 
0423 void PropertyAssignment()                     :
0424 {/*@bgen(jjtree) PropertyAssignment */
0425   ECMAPropertyAssignment jjtn000 = new ECMAPropertyAssignment(this, JJTPROPERTYASSIGNMENT);
0426   boolean jjtc000 = true;
0427   jjtree.openNodeScope(jjtn000);
0428   jjtreeOpenNodeScope(jjtn000);
0429 /*@egen*/}
0430 {/*@bgen(jjtree) PropertyAssignment */
0431         try {
0432 /*@egen*/
0433     PropertyName() ":" AssignmentExpression()/*@bgen(jjtree)*/
0434         } catch (Throwable jjte000) {
0435           if (jjtc000) {
0436             jjtree.clearNodeScope(jjtn000);
0437             jjtc000 = false;
0438           } else {
0439             jjtree.popNode();
0440           }
0441           if (jjte000 instanceof RuntimeException) {
0442             throw (RuntimeException)jjte000;
0443           }
0444           if (jjte000 instanceof ParseException) {
0445             throw (ParseException)jjte000;
0446           }
0447           throw (Error)jjte000;
0448         } finally {
0449           if (jjtc000) {
0450             jjtree.closeNodeScope(jjtn000, true);
0451             jjtreeCloseNodeScope(jjtn000);
0452           }
0453         }
0454 /*@egen*/ 
0455 }
0456 
0457 void PropertyName()       :
0458 {}
0459 {
0460     Identifier() 
0461 |/*@bgen(jjtree) Literal */
0462         {
0463           ECMALiteral jjtn001 = new ECMALiteral(this, JJTLITERAL);
0464           boolean jjtc001 = true;
0465           jjtree.openNodeScope(jjtn001);
0466           jjtreeOpenNodeScope(jjtn001);
0467         }
0468         try {
0469 /*@egen*/   <STRING_LITERAL>/*@bgen(jjtree)*/
0470         } finally {
0471           if (jjtc001) {
0472             jjtree.closeNodeScope(jjtn001, true);
0473             jjtreeCloseNodeScope(jjtn001);
0474           }
0475         }
0476 /*@egen*/         
0477 |/*@bgen(jjtree) Literal */
0478         {
0479           ECMALiteral jjtn002 = new ECMALiteral(this, JJTLITERAL);
0480           boolean jjtc002 = true;
0481           jjtree.openNodeScope(jjtn002);
0482           jjtreeOpenNodeScope(jjtn002);
0483         }
0484         try {
0485 /*@egen*/   <DECIMAL_LITERAL>/*@bgen(jjtree)*/
0486         } finally {
0487           if (jjtc002) {
0488             jjtree.closeNodeScope(jjtn002, true);
0489             jjtreeCloseNodeScope(jjtn002);
0490           }
0491         }
0492 /*@egen*/         
0493 }
0494 
0495 /* ECMA-262 5.1 Edition / June 2011 - Section 11.2: Left-Hand-Side Expressions */
0496 
0497 void MemberExpression()       :
0498 {}
0499 {/*@bgen(jjtree) #Access(> 1) */
0500         {
0501           ECMAAccess jjtn002 = new ECMAAccess(this, JJTACCESS);
0502           boolean jjtc002 = true;
0503           jjtree.openNodeScope(jjtn002);
0504           jjtreeOpenNodeScope(jjtn002);
0505         }
0506         try {
0507 /*@egen*/
0508     (   (   PrimaryExpression()  
0509         |   FunctionExpression()
0510         |/*@bgen(jjtree) NewOperation */
0511                         {
0512                           ECMANewOperation jjtn001 = new ECMANewOperation(this, JJTNEWOPERATION);
0513                           boolean jjtc001 = true;
0514                           jjtree.openNodeScope(jjtn001);
0515                           jjtreeOpenNodeScope(jjtn001);
0516                         }
0517                         try {
0518 /*@egen*/   ( "new" MemberExpression() Arguments() )/*@bgen(jjtree)*/
0519                         } catch (Throwable jjte001) {
0520                           if (jjtc001) {
0521                             jjtree.clearNodeScope(jjtn001);
0522                             jjtc001 = false;
0523                           } else {
0524                             jjtree.popNode();
0525                           }
0526                           if (jjte001 instanceof RuntimeException) {
0527                             throw (RuntimeException)jjte001;
0528                           }
0529                           if (jjte001 instanceof ParseException) {
0530                             throw (ParseException)jjte001;
0531                           }
0532                           throw (Error)jjte001;
0533                         } finally {
0534                           if (jjtc001) {
0535                             jjtree.closeNodeScope(jjtn001, true);
0536                             jjtreeCloseNodeScope(jjtn001);
0537                           }
0538                         }
0539 /*@egen*/              
0540         ) (LOOKAHEAD(1) PropertyAccessor())*
0541     )/*@bgen(jjtree)*/
0542         } catch (Throwable jjte002) {
0543           if (jjtc002) {
0544             jjtree.clearNodeScope(jjtn002);
0545             jjtc002 = false;
0546           } else {
0547             jjtree.popNode();
0548           }
0549           if (jjte002 instanceof RuntimeException) {
0550             throw (RuntimeException)jjte002;
0551           }
0552           if (jjte002 instanceof ParseException) {
0553             throw (ParseException)jjte002;
0554           }
0555           throw (Error)jjte002;
0556         } finally {
0557           if (jjtc002) {
0558             jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() > 1);
0559             jjtreeCloseNodeScope(jjtn002);
0560           }
0561         }
0562 /*@egen*/            
0563 }
0564 
0565 void NewExpression()       :
0566 {}
0567 {
0568     LOOKAHEAD(MemberExpression()) MemberExpression()
0569 |/*@bgen(jjtree) Allocation */
0570         {
0571           ECMAAllocation jjtn001 = new ECMAAllocation(this, JJTALLOCATION);
0572           boolean jjtc001 = true;
0573           jjtree.openNodeScope(jjtn001);
0574           jjtreeOpenNodeScope(jjtn001);
0575         }
0576         try {
0577 /*@egen*/   ( "new" NewExpression() )/*@bgen(jjtree)*/
0578         } catch (Throwable jjte001) {
0579           if (jjtc001) {
0580             jjtree.clearNodeScope(jjtn001);
0581             jjtc001 = false;
0582           } else {
0583             jjtree.popNode();
0584           }
0585           if (jjte001 instanceof RuntimeException) {
0586             throw (RuntimeException)jjte001;
0587           }
0588           if (jjte001 instanceof ParseException) {
0589             throw (ParseException)jjte001;
0590           }
0591           throw (Error)jjte001;
0592         } finally {
0593           if (jjtc001) {
0594             jjtree.closeNodeScope(jjtn001, true);
0595             jjtreeCloseNodeScope(jjtn001);
0596           }
0597         }
0598 /*@egen*/            
0599 }
0600 
0601 void PropertyAccessor()       :
0602 {}
0603 {/*@bgen(jjtree) ArrayAccessor */
0604         {
0605           ECMAArrayAccessor jjtn001 = new ECMAArrayAccessor(this, JJTARRAYACCESSOR);
0606           boolean jjtc001 = true;
0607           jjtree.openNodeScope(jjtn001);
0608           jjtreeOpenNodeScope(jjtn001);
0609         }
0610         try {
0611 /*@egen*/
0612     ( "[" Expression() "]" )/*@bgen(jjtree)*/
0613         } catch (Throwable jjte001) {
0614           if (jjtc001) {
0615             jjtree.clearNodeScope(jjtn001);
0616             jjtc001 = false;
0617           } else {
0618             jjtree.popNode();
0619           }
0620           if (jjte001 instanceof RuntimeException) {
0621             throw (RuntimeException)jjte001;
0622           }
0623           if (jjte001 instanceof ParseException) {
0624             throw (ParseException)jjte001;
0625           }
0626           throw (Error)jjte001;
0627         } finally {
0628           if (jjtc001) {
0629             jjtree.closeNodeScope(jjtn001, true);
0630             jjtreeCloseNodeScope(jjtn001);
0631           }
0632         }
0633 /*@egen*/               
0634 |/*@bgen(jjtree) MemberAccessor */
0635         {
0636           ECMAMemberAccessor jjtn002 = new ECMAMemberAccessor(this, JJTMEMBERACCESSOR);
0637           boolean jjtc002 = true;
0638           jjtree.openNodeScope(jjtn002);
0639           jjtreeOpenNodeScope(jjtn002);
0640         }
0641         try {
0642 /*@egen*/   ( "." Identifier() )/*@bgen(jjtree)*/
0643         } catch (Throwable jjte002) {
0644           if (jjtc002) {
0645             jjtree.clearNodeScope(jjtn002);
0646             jjtc002 = false;
0647           } else {
0648             jjtree.popNode();
0649           }
0650           if (jjte002 instanceof RuntimeException) {
0651             throw (RuntimeException)jjte002;
0652           }
0653           if (jjte002 instanceof ParseException) {
0654             throw (ParseException)jjte002;
0655           }
0656           throw (Error)jjte002;
0657         } finally {
0658           if (jjtc002) {
0659             jjtree.closeNodeScope(jjtn002, true);
0660             jjtreeCloseNodeScope(jjtn002);
0661           }
0662         }
0663 /*@egen*/                
0664 }
0665 
0666 void CallExpression()             : 
0667 {/*@bgen(jjtree) #Access(> 1) */
0668   ECMAAccess jjtn000 = new ECMAAccess(this, JJTACCESS);
0669   boolean jjtc000 = true;
0670   jjtree.openNodeScope(jjtn000);
0671   jjtreeOpenNodeScope(jjtn000);
0672 /*@egen*/}
0673 {/*@bgen(jjtree) #Access(> 1) */
0674         try {
0675 /*@egen*/
0676     MemberExpression() Arguments() ( LOOKAHEAD(2) ( Arguments() | PropertyAccessor() ) )*/*@bgen(jjtree)*/
0677         } catch (Throwable jjte000) {
0678           if (jjtc000) {
0679             jjtree.clearNodeScope(jjtn000);
0680             jjtc000 = false;
0681           } else {
0682             jjtree.popNode();
0683           }
0684           if (jjte000 instanceof RuntimeException) {
0685             throw (RuntimeException)jjte000;
0686           }
0687           if (jjte000 instanceof ParseException) {
0688             throw (ParseException)jjte000;
0689           }
0690           throw (Error)jjte000;
0691         } finally {
0692           if (jjtc000) {
0693             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0694             jjtreeCloseNodeScope(jjtn000);
0695           }
0696         }
0697 /*@egen*/
0698 }
0699 
0700 void Arguments()            :
0701 {/*@bgen(jjtree) Arguments */
0702   ECMAArguments jjtn000 = new ECMAArguments(this, JJTARGUMENTS);
0703   boolean jjtc000 = true;
0704   jjtree.openNodeScope(jjtn000);
0705   jjtreeOpenNodeScope(jjtn000);
0706 /*@egen*/}
0707 {/*@bgen(jjtree) Arguments */
0708         try {
0709 /*@egen*/
0710     "(" (ArgumentList())? ")"/*@bgen(jjtree)*/
0711         } catch (Throwable jjte000) {
0712           if (jjtc000) {
0713             jjtree.clearNodeScope(jjtn000);
0714             jjtc000 = false;
0715           } else {
0716             jjtree.popNode();
0717           }
0718           if (jjte000 instanceof RuntimeException) {
0719             throw (RuntimeException)jjte000;
0720           }
0721           if (jjte000 instanceof ParseException) {
0722             throw (ParseException)jjte000;
0723           }
0724           throw (Error)jjte000;
0725         } finally {
0726           if (jjtc000) {
0727             jjtree.closeNodeScope(jjtn000, true);
0728             jjtreeCloseNodeScope(jjtn000);
0729           }
0730         }
0731 /*@egen*/
0732 }
0733 
0734 void ArgumentList()       :
0735 {}
0736 {
0737     AssignmentExpression() ("," AssignmentExpression())*
0738 }
0739 
0740 void LeftHandSideExpression()       : 
0741 {}
0742 {
0743     LOOKAHEAD(MemberExpression() "(") CallExpression() | NewExpression() 
0744 }
0745 
0746 /* ECMA-262 5.1 Edition / June 2011 - Section 11.3 Postfix Expressions */
0747 
0748 void PostfixExpression()                        :
0749 {/*@bgen(jjtree) #PostfixExpression(> 1) */
0750   ECMAPostfixExpression jjtn000 = new ECMAPostfixExpression(this, JJTPOSTFIXEXPRESSION);
0751   boolean jjtc000 = true;
0752   jjtree.openNodeScope(jjtn000);
0753   jjtreeOpenNodeScope(jjtn000);
0754 /*@egen*/}
0755 {/*@bgen(jjtree) #PostfixExpression(> 1) */
0756         try {
0757 /*@egen*/
0758     LeftHandSideExpression() [ LOOKAHEAD(1)/*@bgen(jjtree) Operator */
0759                                                 {
0760                                                   ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0761                                                   boolean jjtc001 = true;
0762                                                   jjtree.openNodeScope(jjtn001);
0763                                                   jjtreeOpenNodeScope(jjtn001);
0764                                                 }
0765                                                 try {
0766 /*@egen*/ ( "++" | "--" )/*@bgen(jjtree)*/
0767                                                 } finally {
0768                                                   if (jjtc001) {
0769                                                     jjtree.closeNodeScope(jjtn001, true);
0770                                                     jjtreeCloseNodeScope(jjtn001);
0771                                                   }
0772                                                 }
0773 /*@egen*/           ]/*@bgen(jjtree)*/
0774         } catch (Throwable jjte000) {
0775           if (jjtc000) {
0776             jjtree.clearNodeScope(jjtn000);
0777             jjtc000 = false;
0778           } else {
0779             jjtree.popNode();
0780           }
0781           if (jjte000 instanceof RuntimeException) {
0782             throw (RuntimeException)jjte000;
0783           }
0784           if (jjte000 instanceof ParseException) {
0785             throw (ParseException)jjte000;
0786           }
0787           throw (Error)jjte000;
0788         } finally {
0789           if (jjtc000) {
0790             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0791             jjtreeCloseNodeScope(jjtn000);
0792           }
0793         }
0794 /*@egen*/
0795 }
0796 
0797 /* ECMA-262 5.1 Edition / June 2011 - Section 11.4 Unary Operators */
0798 
0799 void UnaryExpression()                      :
0800 {/*@bgen(jjtree) #UnaryExpression(> 1) */
0801   ECMAUnaryExpression jjtn000 = new ECMAUnaryExpression(this, JJTUNARYEXPRESSION);
0802   boolean jjtc000 = true;
0803   jjtree.openNodeScope(jjtn000);
0804   jjtreeOpenNodeScope(jjtn000);
0805 /*@egen*/}
0806 {/*@bgen(jjtree) #UnaryExpression(> 1) */
0807         try {
0808 /*@egen*/ 
0809     PostfixExpression()
0810 |   (/*@bgen(jjtree) Operator */
0811                 {
0812                   ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0813                   boolean jjtc001 = true;
0814                   jjtree.openNodeScope(jjtn001);
0815                   jjtreeOpenNodeScope(jjtn001);
0816                 }
0817                 try {
0818 /*@egen*/
0819         (
0820             "delete"
0821         |   "void"
0822         |   "typeof"
0823         |   "++"
0824         |   "--"
0825         |   "+"
0826         |   "-"
0827         |   "~"
0828         |   "!"
0829         )/*@bgen(jjtree)*/
0830                 } finally {
0831                   if (jjtc001) {
0832                     jjtree.closeNodeScope(jjtn001, true);
0833                     jjtreeCloseNodeScope(jjtn001);
0834                   }
0835                 }
0836 /*@egen*/           UnaryExpression()
0837     )/*@bgen(jjtree)*/
0838         } catch (Throwable jjte000) {
0839           if (jjtc000) {
0840             jjtree.clearNodeScope(jjtn000);
0841             jjtc000 = false;
0842           } else {
0843             jjtree.popNode();
0844           }
0845           if (jjte000 instanceof RuntimeException) {
0846             throw (RuntimeException)jjte000;
0847           }
0848           if (jjte000 instanceof ParseException) {
0849             throw (ParseException)jjte000;
0850           }
0851           throw (Error)jjte000;
0852         } finally {
0853           if (jjtc000) {
0854             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0855             jjtreeCloseNodeScope(jjtn000);
0856           }
0857         }
0858 /*@egen*/
0859 }
0860 
0861 /* ECMA-262 5.1 Edition / June 2011 - Section 11.5: Multiplicative Operators */
0862 
0863 void MultiplicativeExpression()                      :
0864 {/*@bgen(jjtree) #BinaryOperation(> 1) */
0865   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
0866   boolean jjtc000 = true;
0867   jjtree.openNodeScope(jjtn000);
0868   jjtreeOpenNodeScope(jjtn000);
0869 /*@egen*/}
0870 {/*@bgen(jjtree) #BinaryOperation(> 1) */
0871         try {
0872 /*@egen*/ 
0873     UnaryExpression() (/*@bgen(jjtree) Operator */
0874                             {
0875                               ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0876                               boolean jjtc001 = true;
0877                               jjtree.openNodeScope(jjtn001);
0878                               jjtreeOpenNodeScope(jjtn001);
0879                             }
0880                             try {
0881 /*@egen*/ ( "*" | "/" | "%" )/*@bgen(jjtree)*/
0882                             } finally {
0883                               if (jjtc001) {
0884                                 jjtree.closeNodeScope(jjtn001, true);
0885                                 jjtreeCloseNodeScope(jjtn001);
0886                               }
0887                             }
0888 /*@egen*/           UnaryExpression() )*/*@bgen(jjtree)*/
0889         } catch (Throwable jjte000) {
0890           if (jjtc000) {
0891             jjtree.clearNodeScope(jjtn000);
0892             jjtc000 = false;
0893           } else {
0894             jjtree.popNode();
0895           }
0896           if (jjte000 instanceof RuntimeException) {
0897             throw (RuntimeException)jjte000;
0898           }
0899           if (jjte000 instanceof ParseException) {
0900             throw (ParseException)jjte000;
0901           }
0902           throw (Error)jjte000;
0903         } finally {
0904           if (jjtc000) {
0905             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0906             jjtreeCloseNodeScope(jjtn000);
0907           }
0908         }
0909 /*@egen*/
0910 }
0911 
0912 /* ECMA-262 5.1 Edition / June 2011 - Section 11.6: Additive Operators */
0913 
0914 void AdditiveExpression()                      : 
0915 {/*@bgen(jjtree) #BinaryOperation(> 1) */
0916   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
0917   boolean jjtc000 = true;
0918   jjtree.openNodeScope(jjtn000);
0919   jjtreeOpenNodeScope(jjtn000);
0920 /*@egen*/}
0921 {/*@bgen(jjtree) #BinaryOperation(> 1) */
0922         try {
0923 /*@egen*/
0924     MultiplicativeExpression() ( LOOKAHEAD(1)/*@bgen(jjtree) Operator */
0925                                                   {
0926                                                     ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0927                                                     boolean jjtc001 = true;
0928                                                     jjtree.openNodeScope(jjtn001);
0929                                                     jjtreeOpenNodeScope(jjtn001);
0930                                                   }
0931                                                   try {
0932 /*@egen*/ ( "+" | "-" )/*@bgen(jjtree)*/
0933                                                   } finally {
0934                                                     if (jjtc001) {
0935                                                       jjtree.closeNodeScope(jjtn001, true);
0936                                                       jjtreeCloseNodeScope(jjtn001);
0937                                                     }
0938                                                   }
0939 /*@egen*/           MultiplicativeExpression())*/*@bgen(jjtree)*/
0940         } catch (Throwable jjte000) {
0941           if (jjtc000) {
0942             jjtree.clearNodeScope(jjtn000);
0943             jjtc000 = false;
0944           } else {
0945             jjtree.popNode();
0946           }
0947           if (jjte000 instanceof RuntimeException) {
0948             throw (RuntimeException)jjte000;
0949           }
0950           if (jjte000 instanceof ParseException) {
0951             throw (ParseException)jjte000;
0952           }
0953           throw (Error)jjte000;
0954         } finally {
0955           if (jjtc000) {
0956             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0957             jjtreeCloseNodeScope(jjtn000);
0958           }
0959         }
0960 /*@egen*/
0961 }
0962 
0963 /* ECMA-262 5.1 Edition / June 2011 - Section 11.7: Bitwise Shift Operators */
0964 
0965 void ShiftExpression()                      :
0966 {/*@bgen(jjtree) #BinaryOperation(> 1) */
0967   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
0968   boolean jjtc000 = true;
0969   jjtree.openNodeScope(jjtn000);
0970   jjtreeOpenNodeScope(jjtn000);
0971 /*@egen*/}
0972 {/*@bgen(jjtree) #BinaryOperation(> 1) */
0973         try {
0974 /*@egen*/
0975     AdditiveExpression() (/*@bgen(jjtree) Operator */
0976                                {
0977                                  ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0978                                  boolean jjtc001 = true;
0979                                  jjtree.openNodeScope(jjtn001);
0980                                  jjtreeOpenNodeScope(jjtn001);
0981                                }
0982                                try {
0983 /*@egen*/ ( "<<" | ">>" | ">>>" )/*@bgen(jjtree)*/
0984                                } finally {
0985                                  if (jjtc001) {
0986                                    jjtree.closeNodeScope(jjtn001, true);
0987                                    jjtreeCloseNodeScope(jjtn001);
0988                                  }
0989                                }
0990 /*@egen*/           AdditiveExpression() )*/*@bgen(jjtree)*/
0991         } catch (Throwable jjte000) {
0992           if (jjtc000) {
0993             jjtree.clearNodeScope(jjtn000);
0994             jjtc000 = false;
0995           } else {
0996             jjtree.popNode();
0997           }
0998           if (jjte000 instanceof RuntimeException) {
0999             throw (RuntimeException)jjte000;
1000           }
1001           if (jjte000 instanceof ParseException) {
1002             throw (ParseException)jjte000;
1003           }
1004           throw (Error)jjte000;
1005         } finally {
1006           if (jjtc000) {
1007             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1008             jjtreeCloseNodeScope(jjtn000);
1009           }
1010         }
1011 /*@egen*/
1012 }
1013 
1014 /* ECMA-262 5.1 Edition / June 2011 - Section 11.8: Relational Operators */
1015 
1016 void RelationalExpression()                      :
1017 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1018   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1019   boolean jjtc000 = true;
1020   jjtree.openNodeScope(jjtn000);
1021   jjtreeOpenNodeScope(jjtn000);
1022 /*@egen*/}
1023 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1024         try {
1025 /*@egen*/
1026     ShiftExpression() (/*@bgen(jjtree) Operator */
1027                             {
1028                               ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1029                               boolean jjtc001 = true;
1030                               jjtree.openNodeScope(jjtn001);
1031                               jjtreeOpenNodeScope(jjtn001);
1032                             }
1033                             try {
1034 /*@egen*/ ( RelationalOperatorNoIn() | "in" )/*@bgen(jjtree)*/
1035                             } catch (Throwable jjte001) {
1036                               if (jjtc001) {
1037                                 jjtree.clearNodeScope(jjtn001);
1038                                 jjtc001 = false;
1039                               } else {
1040                                 jjtree.popNode();
1041                               }
1042                               if (jjte001 instanceof RuntimeException) {
1043                                 throw (RuntimeException)jjte001;
1044                               }
1045                               if (jjte001 instanceof ParseException) {
1046                                 throw (ParseException)jjte001;
1047                               }
1048                               throw (Error)jjte001;
1049                             } finally {
1050                               if (jjtc001) {
1051                                 jjtree.closeNodeScope(jjtn001, true);
1052                                 jjtreeCloseNodeScope(jjtn001);
1053                               }
1054                             }
1055 /*@egen*/           ShiftExpression() )*/*@bgen(jjtree)*/
1056         } catch (Throwable jjte000) {
1057           if (jjtc000) {
1058             jjtree.clearNodeScope(jjtn000);
1059             jjtc000 = false;
1060           } else {
1061             jjtree.popNode();
1062           }
1063           if (jjte000 instanceof RuntimeException) {
1064             throw (RuntimeException)jjte000;
1065           }
1066           if (jjte000 instanceof ParseException) {
1067             throw (ParseException)jjte000;
1068           }
1069           throw (Error)jjte000;
1070         } finally {
1071           if (jjtc000) {
1072             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1073             jjtreeCloseNodeScope(jjtn000);
1074           }
1075         }
1076 /*@egen*/
1077 }
1078 
1079 void RelationalExpressionNoIn()                      :
1080 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1081   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1082   boolean jjtc000 = true;
1083   jjtree.openNodeScope(jjtn000);
1084   jjtreeOpenNodeScope(jjtn000);
1085 /*@egen*/}
1086 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1087         try {
1088 /*@egen*/
1089     ShiftExpression() (/*@bgen(jjtree) Operator */
1090                             {
1091                               ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1092                               boolean jjtc001 = true;
1093                               jjtree.openNodeScope(jjtn001);
1094                               jjtreeOpenNodeScope(jjtn001);
1095                             }
1096                             try {
1097 /*@egen*/ RelationalOperatorNoIn()/*@bgen(jjtree)*/
1098                             } catch (Throwable jjte001) {
1099                               if (jjtc001) {
1100                                 jjtree.clearNodeScope(jjtn001);
1101                                 jjtc001 = false;
1102                               } else {
1103                                 jjtree.popNode();
1104                               }
1105                               if (jjte001 instanceof RuntimeException) {
1106                                 throw (RuntimeException)jjte001;
1107                               }
1108                               if (jjte001 instanceof ParseException) {
1109                                 throw (ParseException)jjte001;
1110                               }
1111                               throw (Error)jjte001;
1112                             } finally {
1113                               if (jjtc001) {
1114                                 jjtree.closeNodeScope(jjtn001, true);
1115                                 jjtreeCloseNodeScope(jjtn001);
1116                               }
1117                             }
1118 /*@egen*/           ShiftExpression() )*/*@bgen(jjtree)*/
1119         } catch (Throwable jjte000) {
1120           if (jjtc000) {
1121             jjtree.clearNodeScope(jjtn000);
1122             jjtc000 = false;
1123           } else {
1124             jjtree.popNode();
1125           }
1126           if (jjte000 instanceof RuntimeException) {
1127             throw (RuntimeException)jjte000;
1128           }
1129           if (jjte000 instanceof ParseException) {
1130             throw (ParseException)jjte000;
1131           }
1132           throw (Error)jjte000;
1133         } finally {
1134           if (jjtc000) {
1135             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1136             jjtreeCloseNodeScope(jjtn000);
1137           }
1138         }
1139 /*@egen*/
1140 }
1141 
1142 void RelationalOperatorNoIn()       :
1143 {}
1144 {
1145     "<" | ">" | "<=" | ">=" | "instanceof"
1146 }
1147 
1148 /* ECMA-262 5.1 Edition / June 2011 - Section 11.9: Equality Operators */
1149 
1150 void EqualityExpression()                      :
1151 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1152   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1153   boolean jjtc000 = true;
1154   jjtree.openNodeScope(jjtn000);
1155   jjtreeOpenNodeScope(jjtn000);
1156 /*@egen*/}
1157 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1158         try {
1159 /*@egen*/
1160     RelationalExpression() ( EqualityOperator() RelationalExpression() )*/*@bgen(jjtree)*/
1161         } catch (Throwable jjte000) {
1162           if (jjtc000) {
1163             jjtree.clearNodeScope(jjtn000);
1164             jjtc000 = false;
1165           } else {
1166             jjtree.popNode();
1167           }
1168           if (jjte000 instanceof RuntimeException) {
1169             throw (RuntimeException)jjte000;
1170           }
1171           if (jjte000 instanceof ParseException) {
1172             throw (ParseException)jjte000;
1173           }
1174           throw (Error)jjte000;
1175         } finally {
1176           if (jjtc000) {
1177             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1178             jjtreeCloseNodeScope(jjtn000);
1179           }
1180         }
1181 /*@egen*/
1182 }
1183 
1184 void EqualityExpressionNoIn()                      :
1185 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1186   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1187   boolean jjtc000 = true;
1188   jjtree.openNodeScope(jjtn000);
1189   jjtreeOpenNodeScope(jjtn000);
1190 /*@egen*/}
1191 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1192         try {
1193 /*@egen*/
1194     RelationalExpressionNoIn() ( EqualityOperator() RelationalExpressionNoIn())*/*@bgen(jjtree)*/
1195         } catch (Throwable jjte000) {
1196           if (jjtc000) {
1197             jjtree.clearNodeScope(jjtn000);
1198             jjtc000 = false;
1199           } else {
1200             jjtree.popNode();
1201           }
1202           if (jjte000 instanceof RuntimeException) {
1203             throw (RuntimeException)jjte000;
1204           }
1205           if (jjte000 instanceof ParseException) {
1206             throw (ParseException)jjte000;
1207           }
1208           throw (Error)jjte000;
1209         } finally {
1210           if (jjtc000) {
1211             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1212             jjtreeCloseNodeScope(jjtn000);
1213           }
1214         }
1215 /*@egen*/
1216 }
1217 
1218 void EqualityOperator()           :
1219 {/*@bgen(jjtree) Operator */
1220   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1221   boolean jjtc000 = true;
1222   jjtree.openNodeScope(jjtn000);
1223   jjtreeOpenNodeScope(jjtn000);
1224 /*@egen*/}
1225 {/*@bgen(jjtree) Operator */
1226         try {
1227 /*@egen*/
1228     "==" | "!=" | "===" | "!=="/*@bgen(jjtree)*/
1229         } finally {
1230           if (jjtc000) {
1231             jjtree.closeNodeScope(jjtn000, true);
1232             jjtreeCloseNodeScope(jjtn000);
1233           }
1234         }
1235 /*@egen*/
1236 }
1237 
1238 /* ECMA-262 5.1 Edition / June 2011 - Section 11.10: Binary Bitwise Operators */
1239 
1240 void BitwiseANDExpression()                      :
1241 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1242   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1243   boolean jjtc000 = true;
1244   jjtree.openNodeScope(jjtn000);
1245   jjtreeOpenNodeScope(jjtn000);
1246 /*@egen*/}
1247 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1248         try {
1249 /*@egen*/
1250     EqualityExpression() ( BitwiseANDOperator() EqualityExpression())*/*@bgen(jjtree)*/
1251         } catch (Throwable jjte000) {
1252           if (jjtc000) {
1253             jjtree.clearNodeScope(jjtn000);
1254             jjtc000 = false;
1255           } else {
1256             jjtree.popNode();
1257           }
1258           if (jjte000 instanceof RuntimeException) {
1259             throw (RuntimeException)jjte000;
1260           }
1261           if (jjte000 instanceof ParseException) {
1262             throw (ParseException)jjte000;
1263           }
1264           throw (Error)jjte000;
1265         } finally {
1266           if (jjtc000) {
1267             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1268             jjtreeCloseNodeScope(jjtn000);
1269           }
1270         }
1271 /*@egen*/
1272 }
1273 
1274 void BitwiseANDExpressionNoIn()                      :
1275 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1276   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1277   boolean jjtc000 = true;
1278   jjtree.openNodeScope(jjtn000);
1279   jjtreeOpenNodeScope(jjtn000);
1280 /*@egen*/}
1281 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1282         try {
1283 /*@egen*/
1284     EqualityExpressionNoIn() (BitwiseANDOperator() EqualityExpressionNoIn())*/*@bgen(jjtree)*/
1285         } catch (Throwable jjte000) {
1286           if (jjtc000) {
1287             jjtree.clearNodeScope(jjtn000);
1288             jjtc000 = false;
1289           } else {
1290             jjtree.popNode();
1291           }
1292           if (jjte000 instanceof RuntimeException) {
1293             throw (RuntimeException)jjte000;
1294           }
1295           if (jjte000 instanceof ParseException) {
1296             throw (ParseException)jjte000;
1297           }
1298           throw (Error)jjte000;
1299         } finally {
1300           if (jjtc000) {
1301             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1302             jjtreeCloseNodeScope(jjtn000);
1303           }
1304         }
1305 /*@egen*/
1306 }
1307 
1308 void BitwiseANDOperator()           :
1309 {/*@bgen(jjtree) Operator */
1310   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1311   boolean jjtc000 = true;
1312   jjtree.openNodeScope(jjtn000);
1313   jjtreeOpenNodeScope(jjtn000);
1314 /*@egen*/}
1315 {/*@bgen(jjtree) Operator */
1316         try {
1317 /*@egen*/
1318     "&"/*@bgen(jjtree)*/
1319         } finally {
1320           if (jjtc000) {
1321             jjtree.closeNodeScope(jjtn000, true);
1322             jjtreeCloseNodeScope(jjtn000);
1323           }
1324         }
1325 /*@egen*/
1326 }
1327 
1328 void BitwiseXORExpression()                      :
1329 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1330   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1331   boolean jjtc000 = true;
1332   jjtree.openNodeScope(jjtn000);
1333   jjtreeOpenNodeScope(jjtn000);
1334 /*@egen*/}
1335 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1336         try {
1337 /*@egen*/
1338     BitwiseANDExpression() (BitwiseXOROperator() BitwiseANDExpression())*/*@bgen(jjtree)*/
1339         } catch (Throwable jjte000) {
1340           if (jjtc000) {
1341             jjtree.clearNodeScope(jjtn000);
1342             jjtc000 = false;
1343           } else {
1344             jjtree.popNode();
1345           }
1346           if (jjte000 instanceof RuntimeException) {
1347             throw (RuntimeException)jjte000;
1348           }
1349           if (jjte000 instanceof ParseException) {
1350             throw (ParseException)jjte000;
1351           }
1352           throw (Error)jjte000;
1353         } finally {
1354           if (jjtc000) {
1355             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1356             jjtreeCloseNodeScope(jjtn000);
1357           }
1358         }
1359 /*@egen*/
1360 }
1361 
1362 void BitwiseXORExpressionNoIn()                      :
1363 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1364   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1365   boolean jjtc000 = true;
1366   jjtree.openNodeScope(jjtn000);
1367   jjtreeOpenNodeScope(jjtn000);
1368 /*@egen*/}
1369 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1370         try {
1371 /*@egen*/
1372     BitwiseANDExpressionNoIn() (BitwiseXOROperator() BitwiseANDExpressionNoIn())*/*@bgen(jjtree)*/
1373         } catch (Throwable jjte000) {
1374           if (jjtc000) {
1375             jjtree.clearNodeScope(jjtn000);
1376             jjtc000 = false;
1377           } else {
1378             jjtree.popNode();
1379           }
1380           if (jjte000 instanceof RuntimeException) {
1381             throw (RuntimeException)jjte000;
1382           }
1383           if (jjte000 instanceof ParseException) {
1384             throw (ParseException)jjte000;
1385           }
1386           throw (Error)jjte000;
1387         } finally {
1388           if (jjtc000) {
1389             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1390             jjtreeCloseNodeScope(jjtn000);
1391           }
1392         }
1393 /*@egen*/
1394 }
1395 
1396 void BitwiseXOROperator()           :
1397 {/*@bgen(jjtree) Operator */
1398   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1399   boolean jjtc000 = true;
1400   jjtree.openNodeScope(jjtn000);
1401   jjtreeOpenNodeScope(jjtn000);
1402 /*@egen*/}
1403 {/*@bgen(jjtree) Operator */
1404         try {
1405 /*@egen*/
1406     "^"/*@bgen(jjtree)*/
1407         } finally {
1408           if (jjtc000) {
1409             jjtree.closeNodeScope(jjtn000, true);
1410             jjtreeCloseNodeScope(jjtn000);
1411           }
1412         }
1413 /*@egen*/
1414 }
1415 
1416 void BitwiseORExpression()                      :
1417 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1418   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1419   boolean jjtc000 = true;
1420   jjtree.openNodeScope(jjtn000);
1421   jjtreeOpenNodeScope(jjtn000);
1422 /*@egen*/}
1423 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1424         try {
1425 /*@egen*/
1426     BitwiseXORExpression() (BitwiseOROperator() BitwiseXORExpression())*/*@bgen(jjtree)*/
1427         } catch (Throwable jjte000) {
1428           if (jjtc000) {
1429             jjtree.clearNodeScope(jjtn000);
1430             jjtc000 = false;
1431           } else {
1432             jjtree.popNode();
1433           }
1434           if (jjte000 instanceof RuntimeException) {
1435             throw (RuntimeException)jjte000;
1436           }
1437           if (jjte000 instanceof ParseException) {
1438             throw (ParseException)jjte000;
1439           }
1440           throw (Error)jjte000;
1441         } finally {
1442           if (jjtc000) {
1443             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1444             jjtreeCloseNodeScope(jjtn000);
1445           }
1446         }
1447 /*@egen*/
1448 }
1449 
1450 void BitwiseORExpressionNoIn()                      :
1451 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1452   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1453   boolean jjtc000 = true;
1454   jjtree.openNodeScope(jjtn000);
1455   jjtreeOpenNodeScope(jjtn000);
1456 /*@egen*/}
1457 {/*@bgen(jjtree) #BinaryOperation(> 1) */
1458         try {
1459 /*@egen*/
1460     BitwiseXORExpressionNoIn() (BitwiseOROperator() BitwiseXORExpressionNoIn())*/*@bgen(jjtree)*/
1461         } catch (Throwable jjte000) {
1462           if (jjtc000) {
1463             jjtree.clearNodeScope(jjtn000);
1464             jjtc000 = false;
1465           } else {
1466             jjtree.popNode();
1467           }
1468           if (jjte000 instanceof RuntimeException) {
1469             throw (RuntimeException)jjte000;
1470           }
1471           if (jjte000 instanceof ParseException) {
1472             throw (ParseException)jjte000;
1473           }
1474           throw (Error)jjte000;
1475         } finally {
1476           if (jjtc000) {
1477             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1478             jjtreeCloseNodeScope(jjtn000);
1479           }
1480         }
1481 /*@egen*/
1482 }
1483 
1484 void BitwiseOROperator()           :
1485 {/*@bgen(jjtree) Operator */
1486   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1487   boolean jjtc000 = true;
1488   jjtree.openNodeScope(jjtn000);
1489   jjtreeOpenNodeScope(jjtn000);
1490 /*@egen*/}
1491 {/*@bgen(jjtree) Operator */
1492         try {
1493 /*@egen*/
1494     "|"/*@bgen(jjtree)*/
1495         } finally {
1496           if (jjtc000) {
1497             jjtree.closeNodeScope(jjtn000, true);
1498             jjtreeCloseNodeScope(jjtn000);
1499           }
1500         }
1501 /*@egen*/
1502 }
1503 
1504 /* ECMA-262 5.1 Edition / June 2011 - Section 11.11: Binary Logical Operators */
1505 
1506 void LogicalANDExpression()                   :
1507 {/*@bgen(jjtree) #AndOperation(> 1) */
1508   ECMAAndOperation jjtn000 = new ECMAAndOperation(this, JJTANDOPERATION);
1509   boolean jjtc000 = true;
1510   jjtree.openNodeScope(jjtn000);
1511   jjtreeOpenNodeScope(jjtn000);
1512 /*@egen*/}
1513 {/*@bgen(jjtree) #AndOperation(> 1) */
1514         try {
1515 /*@egen*/
1516     BitwiseORExpression() (LogicalANDOperator() BitwiseORExpression())*/*@bgen(jjtree)*/
1517         } catch (Throwable jjte000) {
1518           if (jjtc000) {
1519             jjtree.clearNodeScope(jjtn000);
1520             jjtc000 = false;
1521           } else {
1522             jjtree.popNode();
1523           }
1524           if (jjte000 instanceof RuntimeException) {
1525             throw (RuntimeException)jjte000;
1526           }
1527           if (jjte000 instanceof ParseException) {
1528             throw (ParseException)jjte000;
1529           }
1530           throw (Error)jjte000;
1531         } finally {
1532           if (jjtc000) {
1533             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1534             jjtreeCloseNodeScope(jjtn000);
1535           }
1536         }
1537 /*@egen*/
1538 }
1539 
1540 void LogicalANDExpressionNoIn()                   :
1541 {/*@bgen(jjtree) #AndOperation(> 1) */
1542   ECMAAndOperation jjtn000 = new ECMAAndOperation(this, JJTANDOPERATION);
1543   boolean jjtc000 = true;
1544   jjtree.openNodeScope(jjtn000);
1545   jjtreeOpenNodeScope(jjtn000);
1546 /*@egen*/}
1547 {/*@bgen(jjtree) #AndOperation(> 1) */
1548         try {
1549 /*@egen*/ 
1550     BitwiseORExpressionNoIn() (LogicalANDOperator() BitwiseORExpressionNoIn())*/*@bgen(jjtree)*/
1551         } catch (Throwable jjte000) {
1552           if (jjtc000) {
1553             jjtree.clearNodeScope(jjtn000);
1554             jjtc000 = false;
1555           } else {
1556             jjtree.popNode();
1557           }
1558           if (jjte000 instanceof RuntimeException) {
1559             throw (RuntimeException)jjte000;
1560           }
1561           if (jjte000 instanceof ParseException) {
1562             throw (ParseException)jjte000;
1563           }
1564           throw (Error)jjte000;
1565         } finally {
1566           if (jjtc000) {
1567             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1568             jjtreeCloseNodeScope(jjtn000);
1569           }
1570         }
1571 /*@egen*/
1572 }
1573 
1574 void LogicalANDOperator()           :
1575 {/*@bgen(jjtree) Operator */
1576   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1577   boolean jjtc000 = true;
1578   jjtree.openNodeScope(jjtn000);
1579   jjtreeOpenNodeScope(jjtn000);
1580 /*@egen*/}
1581 {/*@bgen(jjtree) Operator */
1582         try {
1583 /*@egen*/
1584     "&&"/*@bgen(jjtree)*/
1585         } finally {
1586           if (jjtc000) {
1587             jjtree.closeNodeScope(jjtn000, true);
1588             jjtreeCloseNodeScope(jjtn000);
1589           }
1590         }
1591 /*@egen*/
1592 }
1593 
1594 void LogicalORExpression()                  :
1595 {/*@bgen(jjtree) #OrOperation(> 1) */
1596   ECMAOrOperation jjtn000 = new ECMAOrOperation(this, JJTOROPERATION);
1597   boolean jjtc000 = true;
1598   jjtree.openNodeScope(jjtn000);
1599   jjtreeOpenNodeScope(jjtn000);
1600 /*@egen*/}
1601 {/*@bgen(jjtree) #OrOperation(> 1) */
1602         try {
1603 /*@egen*/
1604     LogicalANDExpression() (LogicalOROperator() LogicalANDExpression())*/*@bgen(jjtree)*/
1605         } catch (Throwable jjte000) {
1606           if (jjtc000) {
1607             jjtree.clearNodeScope(jjtn000);
1608             jjtc000 = false;
1609           } else {
1610             jjtree.popNode();
1611           }
1612           if (jjte000 instanceof RuntimeException) {
1613             throw (RuntimeException)jjte000;
1614           }
1615           if (jjte000 instanceof ParseException) {
1616             throw (ParseException)jjte000;
1617           }
1618           throw (Error)jjte000;
1619         } finally {
1620           if (jjtc000) {
1621             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1622             jjtreeCloseNodeScope(jjtn000);
1623           }
1624         }
1625 /*@egen*/
1626 }
1627 
1628 void LogicalORExpressionNoIn()                  :
1629 {/*@bgen(jjtree) #OrOperation(> 1) */
1630   ECMAOrOperation jjtn000 = new ECMAOrOperation(this, JJTOROPERATION);
1631   boolean jjtc000 = true;
1632   jjtree.openNodeScope(jjtn000);
1633   jjtreeOpenNodeScope(jjtn000);
1634 /*@egen*/}
1635 {/*@bgen(jjtree) #OrOperation(> 1) */
1636         try {
1637 /*@egen*/
1638     LogicalANDExpressionNoIn() (LogicalOROperator() LogicalANDExpressionNoIn())*/*@bgen(jjtree)*/
1639         } catch (Throwable jjte000) {
1640           if (jjtc000) {
1641             jjtree.clearNodeScope(jjtn000);
1642             jjtc000 = false;
1643           } else {
1644             jjtree.popNode();
1645           }
1646           if (jjte000 instanceof RuntimeException) {
1647             throw (RuntimeException)jjte000;
1648           }
1649           if (jjte000 instanceof ParseException) {
1650             throw (ParseException)jjte000;
1651           }
1652           throw (Error)jjte000;
1653         } finally {
1654           if (jjtc000) {
1655             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1656             jjtreeCloseNodeScope(jjtn000);
1657           }
1658         }
1659 /*@egen*/
1660 }
1661 
1662 void LogicalOROperator()           :
1663 {/*@bgen(jjtree) Operator */
1664   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1665   boolean jjtc000 = true;
1666   jjtree.openNodeScope(jjtn000);
1667   jjtreeOpenNodeScope(jjtn000);
1668 /*@egen*/}
1669 {/*@bgen(jjtree) Operator */
1670         try {
1671 /*@egen*/
1672     "||"/*@bgen(jjtree)*/
1673         } finally {
1674           if (jjtc000) {
1675             jjtree.closeNodeScope(jjtn000, true);
1676             jjtreeCloseNodeScope(jjtn000);
1677           }
1678         }
1679 /*@egen*/
1680 }
1681 
1682 /* ECMA-262 5.1 Edition / June 2011 - Section 11.12: Conditional Operator */
1683 
1684 void ConditionalExpression()                            :
1685 {/*@bgen(jjtree) #ConditionalExpression(> 1) */
1686   ECMAConditionalExpression jjtn000 = new ECMAConditionalExpression(this, JJTCONDITIONALEXPRESSION);
1687   boolean jjtc000 = true;
1688   jjtree.openNodeScope(jjtn000);
1689   jjtreeOpenNodeScope(jjtn000);
1690 /*@egen*/}
1691 {/*@bgen(jjtree) #ConditionalExpression(> 1) */
1692         try {
1693 /*@egen*/
1694     LogicalORExpression() [ "?" AssignmentExpression() ":" AssignmentExpression() ]/*@bgen(jjtree)*/
1695         } catch (Throwable jjte000) {
1696           if (jjtc000) {
1697             jjtree.clearNodeScope(jjtn000);
1698             jjtc000 = false;
1699           } else {
1700             jjtree.popNode();
1701           }
1702           if (jjte000 instanceof RuntimeException) {
1703             throw (RuntimeException)jjte000;
1704           }
1705           if (jjte000 instanceof ParseException) {
1706             throw (ParseException)jjte000;
1707           }
1708           throw (Error)jjte000;
1709         } finally {
1710           if (jjtc000) {
1711             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1712             jjtreeCloseNodeScope(jjtn000);
1713           }
1714         }
1715 /*@egen*/
1716 }
1717 
1718 void ConditionalExpressionNoIn()                            :
1719 {/*@bgen(jjtree) #ConditionalExpression(> 1) */
1720   ECMAConditionalExpression jjtn000 = new ECMAConditionalExpression(this, JJTCONDITIONALEXPRESSION);
1721   boolean jjtc000 = true;
1722   jjtree.openNodeScope(jjtn000);
1723   jjtreeOpenNodeScope(jjtn000);
1724 /*@egen*/}
1725 {/*@bgen(jjtree) #ConditionalExpression(> 1) */
1726         try {
1727 /*@egen*/
1728     LogicalORExpressionNoIn() [ "?" AssignmentExpression() ":" AssignmentExpressionNoIn() ]/*@bgen(jjtree)*/
1729         } catch (Throwable jjte000) {
1730           if (jjtc000) {
1731             jjtree.clearNodeScope(jjtn000);
1732             jjtc000 = false;
1733           } else {
1734             jjtree.popNode();
1735           }
1736           if (jjte000 instanceof RuntimeException) {
1737             throw (RuntimeException)jjte000;
1738           }
1739           if (jjte000 instanceof ParseException) {
1740             throw (ParseException)jjte000;
1741           }
1742           throw (Error)jjte000;
1743         } finally {
1744           if (jjtc000) {
1745             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1746             jjtreeCloseNodeScope(jjtn000);
1747           }
1748         }
1749 /*@egen*/
1750 }
1751 
1752 /* ECMA-262 5.1 Edition / June 2011 - Section 11.13: Assignment Operators */
1753 
1754 void AssignmentExpression()                           :
1755 {/*@bgen(jjtree) #AssignmentExpression(> 1) */
1756   ECMAAssignmentExpression jjtn000 = new ECMAAssignmentExpression(this, JJTASSIGNMENTEXPRESSION);
1757   boolean jjtc000 = true;
1758   jjtree.openNodeScope(jjtn000);
1759   jjtreeOpenNodeScope(jjtn000);
1760 /*@egen*/}
1761 {/*@bgen(jjtree) #AssignmentExpression(> 1) */
1762         try {
1763 /*@egen*/
1764     LOOKAHEAD(LeftHandSideExpression() AssignmentOperator()) LeftHandSideExpression() AssignmentOperator() AssignmentExpression() 
1765 |   ConditionalExpression()/*@bgen(jjtree)*/
1766         } catch (Throwable jjte000) {
1767           if (jjtc000) {
1768             jjtree.clearNodeScope(jjtn000);
1769             jjtc000 = false;
1770           } else {
1771             jjtree.popNode();
1772           }
1773           if (jjte000 instanceof RuntimeException) {
1774             throw (RuntimeException)jjte000;
1775           }
1776           if (jjte000 instanceof ParseException) {
1777             throw (ParseException)jjte000;
1778           }
1779           throw (Error)jjte000;
1780         } finally {
1781           if (jjtc000) {
1782             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1783             jjtreeCloseNodeScope(jjtn000);
1784           }
1785         }
1786 /*@egen*/ 
1787 }
1788 
1789 void AssignmentExpressionNoIn()                           : 
1790 {/*@bgen(jjtree) #AssignmentExpression(> 1) */
1791   ECMAAssignmentExpression jjtn000 = new ECMAAssignmentExpression(this, JJTASSIGNMENTEXPRESSION);
1792   boolean jjtc000 = true;
1793   jjtree.openNodeScope(jjtn000);
1794   jjtreeOpenNodeScope(jjtn000);
1795 /*@egen*/}
1796 {/*@bgen(jjtree) #AssignmentExpression(> 1) */
1797         try {
1798 /*@egen*/
1799     LOOKAHEAD(LeftHandSideExpression() AssignmentOperator()) LeftHandSideExpression() AssignmentOperator() AssignmentExpressionNoIn()
1800 |   ConditionalExpressionNoIn()/*@bgen(jjtree)*/
1801         } catch (Throwable jjte000) {
1802           if (jjtc000) {
1803             jjtree.clearNodeScope(jjtn000);
1804             jjtc000 = false;
1805           } else {
1806             jjtree.popNode();
1807           }
1808           if (jjte000 instanceof RuntimeException) {
1809             throw (RuntimeException)jjte000;
1810           }
1811           if (jjte000 instanceof ParseException) {
1812             throw (ParseException)jjte000;
1813           }
1814           throw (Error)jjte000;
1815         } finally {
1816           if (jjtc000) {
1817             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1818             jjtreeCloseNodeScope(jjtn000);
1819           }
1820         }
1821 /*@egen*/ 
1822 }
1823 
1824 void AssignmentOperator()           :
1825 {/*@bgen(jjtree) Operator */
1826   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1827   boolean jjtc000 = true;
1828   jjtree.openNodeScope(jjtn000);
1829   jjtreeOpenNodeScope(jjtn000);
1830 /*@egen*/}
1831 {/*@bgen(jjtree) Operator */
1832         try {
1833 /*@egen*/
1834     "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | ">>>=" | "&=" | "^=" | "|="/*@bgen(jjtree)*/
1835         } finally {
1836           if (jjtc000) {
1837             jjtree.closeNodeScope(jjtn000, true);
1838             jjtreeCloseNodeScope(jjtn000);
1839           }
1840         }
1841 /*@egen*/
1842 }
1843 
1844 /* ECMA-262 5.1 Edition / June 2011 - Section 11.14: Comma Operator */
1845 
1846 void Expression()                      :
1847 {/*@bgen(jjtree) #CommaExpression(> 1) */
1848   ECMACommaExpression jjtn000 = new ECMACommaExpression(this, JJTCOMMAEXPRESSION);
1849   boolean jjtc000 = true;
1850   jjtree.openNodeScope(jjtn000);
1851   jjtreeOpenNodeScope(jjtn000);
1852 /*@egen*/}
1853 {/*@bgen(jjtree) #CommaExpression(> 1) */
1854         try {
1855 /*@egen*/
1856     AssignmentExpression() ( "," AssignmentExpression() )*/*@bgen(jjtree)*/
1857         } catch (Throwable jjte000) {
1858           if (jjtc000) {
1859             jjtree.clearNodeScope(jjtn000);
1860             jjtc000 = false;
1861           } else {
1862             jjtree.popNode();
1863           }
1864           if (jjte000 instanceof RuntimeException) {
1865             throw (RuntimeException)jjte000;
1866           }
1867           if (jjte000 instanceof ParseException) {
1868             throw (ParseException)jjte000;
1869           }
1870           throw (Error)jjte000;
1871         } finally {
1872           if (jjtc000) {
1873             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1874             jjtreeCloseNodeScope(jjtn000);
1875           }
1876         }
1877 /*@egen*/
1878 }
1879 
1880 void ExpressionNoIn()                      :
1881 {/*@bgen(jjtree) #CommaExpression(> 1) */
1882   ECMACommaExpression jjtn000 = new ECMACommaExpression(this, JJTCOMMAEXPRESSION);
1883   boolean jjtc000 = true;
1884   jjtree.openNodeScope(jjtn000);
1885   jjtreeOpenNodeScope(jjtn000);
1886 /*@egen*/}
1887 {/*@bgen(jjtree) #CommaExpression(> 1) */
1888         try {
1889 /*@egen*/
1890     AssignmentExpressionNoIn() ( "," AssignmentExpressionNoIn() )*/*@bgen(jjtree)*/
1891         } catch (Throwable jjte000) {
1892           if (jjtc000) {
1893             jjtree.clearNodeScope(jjtn000);
1894             jjtc000 = false;
1895           } else {
1896             jjtree.popNode();
1897           }
1898           if (jjte000 instanceof RuntimeException) {
1899             throw (RuntimeException)jjte000;
1900           }
1901           if (jjte000 instanceof ParseException) {
1902             throw (ParseException)jjte000;
1903           }
1904           throw (Error)jjte000;
1905         } finally {
1906           if (jjtc000) {
1907             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1908             jjtreeCloseNodeScope(jjtn000);
1909           }
1910         }
1911 /*@egen*/
1912 }
1913 
1914 /* ECMA-262 5.1 Edition / June 2011 - Section 12: STATEMENTS */
1915 
1916 void Statement()       :
1917 {}
1918 {/*@bgen(jjtree) JavaStatement */
1919         {
1920           ECMAJavaStatement jjtn001 = new ECMAJavaStatement(this, JJTJAVASTATEMENT);
1921           boolean jjtc001 = true;
1922           jjtree.openNodeScope(jjtn001);
1923           jjtreeOpenNodeScope(jjtn001);
1924         }
1925         try {
1926 /*@egen*/
1927     < JAVA_STATEMENT >/*@bgen(jjtree)*/
1928         } finally {
1929           if (jjtc001) {
1930             jjtree.closeNodeScope(jjtn001, true);
1931             jjtreeCloseNodeScope(jjtn001);
1932           }
1933         }
1934 /*@egen*/               
1935 |   LOOKAHEAD(Block()) Block()    
1936 |   LOOKAHEAD("var" Identifier()) VariableStatement()
1937 |   DebuggerStatement()
1938 |   EmptyStatement()
1939 |   LOOKAHEAD(Identifier() ":") LabelledStatement()
1940 |   LOOKAHEAD(ExpressionStatement())  ExpressionStatement()
1941 |   LOOKAHEAD("if" "(") IfStatement()
1942 |   IterationStatement()
1943 |   LOOKAHEAD("continue") ContinueStatement()
1944 |   LOOKAHEAD("break") BreakStatement()
1945 |   ReturnStatement()
1946 |   WithStatement()
1947 |   SwitchStatement()
1948 |   ThrowStatement()
1949 |   TryStatement()
1950 }
1951 
1952 /* ECMA-262 5.1 Edition / June 2011 - Section 12.1 Block Statement */
1953 
1954 void Block()        :
1955 {/*@bgen(jjtree) Block */
1956   ECMABlock jjtn000 = new ECMABlock(this, JJTBLOCK);
1957   boolean jjtc000 = true;
1958   jjtree.openNodeScope(jjtn000);
1959   jjtreeOpenNodeScope(jjtn000);
1960 /*@egen*/}
1961 {/*@bgen(jjtree) Block */
1962         try {
1963 /*@egen*/
1964     "{" ( StatementList() )? "}"/*@bgen(jjtree)*/
1965         } catch (Throwable jjte000) {
1966           if (jjtc000) {
1967             jjtree.clearNodeScope(jjtn000);
1968             jjtc000 = false;
1969           } else {
1970             jjtree.popNode();
1971           }
1972           if (jjte000 instanceof RuntimeException) {
1973             throw (RuntimeException)jjte000;
1974           }
1975           if (jjte000 instanceof ParseException) {
1976             throw (ParseException)jjte000;
1977           }
1978           throw (Error)jjte000;
1979         } finally {
1980           if (jjtc000) {
1981             jjtree.closeNodeScope(jjtn000, true);
1982             jjtreeCloseNodeScope(jjtn000);
1983           }
1984         }
1985 /*@egen*/
1986 }
1987 
1988 void StatementList()                    : 
1989 {/*@bgen(jjtree) #StatementList(> 1) */
1990   ECMAStatementList jjtn000 = new ECMAStatementList(this, JJTSTATEMENTLIST);
1991   boolean jjtc000 = true;
1992   jjtree.openNodeScope(jjtn000);
1993   jjtreeOpenNodeScope(jjtn000);
1994 /*@egen*/}
1995 {/*@bgen(jjtree) #StatementList(> 1) */
1996         try {
1997 /*@egen*/
1998     ( Statement() )+/*@bgen(jjtree)*/
1999         } catch (Throwable jjte000) {
2000           if (jjtc000) {
2001             jjtree.clearNodeScope(jjtn000);
2002             jjtc000 = false;
2003           } else {
2004             jjtree.popNode();
2005           }
2006           if (jjte000 instanceof RuntimeException) {
2007             throw (RuntimeException)jjte000;
2008           }
2009           if (jjte000 instanceof ParseException) {
2010             throw (ParseException)jjte000;
2011           }
2012           throw (Error)jjte000;
2013         } finally {
2014           if (jjtc000) {
2015             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2016             jjtreeCloseNodeScope(jjtn000);
2017           }
2018         }
2019 /*@egen*/
2020 }
2021 
2022 /* ECMA-262 5.1 Edition / June 2011 - Section 12.2: Variable statement */
2023 
2024 void VariableStatement()                    :
2025 {/*@bgen(jjtree) VariableStatement */
2026   ECMAVariableStatement jjtn000 = new ECMAVariableStatement(this, JJTVARIABLESTATEMENT);
2027   boolean jjtc000 = true;
2028   jjtree.openNodeScope(jjtn000);
2029   jjtreeOpenNodeScope(jjtn000);
2030 /*@egen*/}
2031 {/*@bgen(jjtree) VariableStatement */
2032         try {
2033 /*@egen*/
2034     "var" VariableDeclarationList() (LOOKAHEAD(2) ";")?/*@bgen(jjtree)*/
2035         } catch (Throwable jjte000) {
2036           if (jjtc000) {
2037             jjtree.clearNodeScope(jjtn000);
2038             jjtc000 = false;
2039           } else {
2040             jjtree.popNode();
2041           }
2042           if (jjte000 instanceof RuntimeException) {
2043             throw (RuntimeException)jjte000;
2044           }
2045           if (jjte000 instanceof ParseException) {
2046             throw (ParseException)jjte000;
2047           }
2048           throw (Error)jjte000;
2049         } finally {
2050           if (jjtc000) {
2051             jjtree.closeNodeScope(jjtn000, true);
2052             jjtreeCloseNodeScope(jjtn000);
2053           }
2054         }
2055 /*@egen*/
2056 }
2057 
2058 void VariableDeclarationList()                              :
2059 {/*@bgen(jjtree) #VariableDeclarationList(> 1) */
2060   ECMAVariableDeclarationList jjtn000 = new ECMAVariableDeclarationList(this, JJTVARIABLEDECLARATIONLIST);
2061   boolean jjtc000 = true;
2062   jjtree.openNodeScope(jjtn000);
2063   jjtreeOpenNodeScope(jjtn000);
2064 /*@egen*/}
2065 {/*@bgen(jjtree) #VariableDeclarationList(> 1) */
2066         try {
2067 /*@egen*/
2068     VariableDeclaration() ( "," VariableDeclaration() )*/*@bgen(jjtree)*/
2069         } catch (Throwable jjte000) {
2070           if (jjtc000) {
2071             jjtree.clearNodeScope(jjtn000);
2072             jjtc000 = false;
2073           } else {
2074             jjtree.popNode();
2075           }
2076           if (jjte000 instanceof RuntimeException) {
2077             throw (RuntimeException)jjte000;
2078           }
2079           if (jjte000 instanceof ParseException) {
2080             throw (ParseException)jjte000;
2081           }
2082           throw (Error)jjte000;
2083         } finally {
2084           if (jjtc000) {
2085             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2086             jjtreeCloseNodeScope(jjtn000);
2087           }
2088         }
2089 /*@egen*/
2090 }
2091 
2092 void VariableDeclarationListNoIn()                              :
2093 {/*@bgen(jjtree) #VariableDeclarationList(> 1) */
2094   ECMAVariableDeclarationList jjtn000 = new ECMAVariableDeclarationList(this, JJTVARIABLEDECLARATIONLIST);
2095   boolean jjtc000 = true;
2096   jjtree.openNodeScope(jjtn000);
2097   jjtreeOpenNodeScope(jjtn000);
2098 /*@egen*/}
2099 {/*@bgen(jjtree) #VariableDeclarationList(> 1) */
2100         try {
2101 /*@egen*/
2102     VariableDeclarationNoIn() ( "," VariableDeclarationNoIn() )*/*@bgen(jjtree)*/
2103         } catch (Throwable jjte000) {
2104           if (jjtc000) {
2105             jjtree.clearNodeScope(jjtn000);
2106             jjtc000 = false;
2107           } else {
2108             jjtree.popNode();
2109           }
2110           if (jjte000 instanceof RuntimeException) {
2111             throw (RuntimeException)jjte000;
2112           }
2113           if (jjte000 instanceof ParseException) {
2114             throw (ParseException)jjte000;
2115           }
2116           throw (Error)jjte000;
2117         } finally {
2118           if (jjtc000) {
2119             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2120             jjtreeCloseNodeScope(jjtn000);
2121           }
2122         }
2123 /*@egen*/
2124 }
2125 
2126 void VariableDeclaration()                      :
2127 {/*@bgen(jjtree) VariableDeclaration */
2128   ECMAVariableDeclaration jjtn000 = new ECMAVariableDeclaration(this, JJTVARIABLEDECLARATION);
2129   boolean jjtc000 = true;
2130   jjtree.openNodeScope(jjtn000);
2131   jjtreeOpenNodeScope(jjtn000);
2132 /*@egen*/}
2133 {/*@bgen(jjtree) VariableDeclaration */
2134         try {
2135 /*@egen*/
2136     Identifier() ( Initialiser() )?/*@bgen(jjtree)*/
2137         } catch (Throwable jjte000) {
2138           if (jjtc000) {
2139             jjtree.clearNodeScope(jjtn000);
2140             jjtc000 = false;
2141           } else {
2142             jjtree.popNode();
2143           }
2144           if (jjte000 instanceof RuntimeException) {
2145             throw (RuntimeException)jjte000;
2146           }
2147           if (jjte000 instanceof ParseException) {
2148             throw (ParseException)jjte000;
2149           }
2150           throw (Error)jjte000;
2151         } finally {
2152           if (jjtc000) {
2153             jjtree.closeNodeScope(jjtn000, true);
2154             jjtreeCloseNodeScope(jjtn000);
2155           }
2156         }
2157 /*@egen*/
2158 }
2159 
2160 void VariableDeclarationNoIn()                      :
2161 {/*@bgen(jjtree) VariableDeclaration */
2162   ECMAVariableDeclaration jjtn000 = new ECMAVariableDeclaration(this, JJTVARIABLEDECLARATION);
2163   boolean jjtc000 = true;
2164   jjtree.openNodeScope(jjtn000);
2165   jjtreeOpenNodeScope(jjtn000);
2166 /*@egen*/}
2167 {/*@bgen(jjtree) VariableDeclaration */
2168         try {
2169 /*@egen*/
2170     Identifier()/*@bgen(jjtree) #EmptyExpression( jjtree . nodeArity ( ) == 0) */
2171                      {
2172                        ECMAEmptyExpression jjtn001 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2173                        boolean jjtc001 = true;
2174                        jjtree.openNodeScope(jjtn001);
2175                        jjtreeOpenNodeScope(jjtn001);
2176                      }
2177                      try {
2178 /*@egen*/ ( InitialiserNoIn() )?/*@bgen(jjtree)*/
2179                      } catch (Throwable jjte001) {
2180                        if (jjtc001) {
2181                          jjtree.clearNodeScope(jjtn001);
2182                          jjtc001 = false;
2183                        } else {
2184                          jjtree.popNode();
2185                        }
2186                        if (jjte001 instanceof RuntimeException) {
2187                          throw (RuntimeException)jjte001;
2188                        }
2189                        if (jjte001 instanceof ParseException) {
2190                          throw (ParseException)jjte001;
2191                        }
2192                        throw (Error)jjte001;
2193                      } finally {
2194                        if (jjtc001) {
2195                          jjtree.closeNodeScope(jjtn001,  jjtree . nodeArity ( ) == 0);
2196                          jjtreeCloseNodeScope(jjtn001);
2197                        }
2198                      }
2199 /*@egen*/                                        /*@bgen(jjtree)*/
2200         } catch (Throwable jjte000) {
2201           if (jjtc000) {
2202             jjtree.clearNodeScope(jjtn000);
2203             jjtc000 = false;
2204           } else {
2205             jjtree.popNode();
2206           }
2207           if (jjte000 instanceof RuntimeException) {
2208             throw (RuntimeException)jjte000;
2209           }
2210           if (jjte000 instanceof ParseException) {
2211             throw (ParseException)jjte000;
2212           }
2213           throw (Error)jjte000;
2214         } finally {
2215           if (jjtc000) {
2216             jjtree.closeNodeScope(jjtn000, true);
2217             jjtreeCloseNodeScope(jjtn000);
2218           }
2219         }
2220 /*@egen*/
2221 }
2222 
2223 void Initialiser()       :
2224 {}
2225 {
2226     "=" AssignmentExpression()
2227 }
2228 
2229 void InitialiserNoIn()       :
2230 {}
2231 {
2232     "=" AssignmentExpressionNoIn()
2233 }
2234 
2235 /* ECMA-262 5.1 Edition / June 2011 - Section 12.3: Empty Statement */
2236 
2237 void EmptyStatement()       :
2238 {}
2239 {
2240     ";"
2241 }
2242 
2243 /* ECMA-262 5.1 Edition / June 2011 - Section 12.4: Expression Statement */
2244 
2245 void ExpressionStatement()                      :
2246 {/*@bgen(jjtree) ExpressionStatement */
2247   ECMAExpressionStatement jjtn000 = new ECMAExpressionStatement(this, JJTEXPRESSIONSTATEMENT);
2248   boolean jjtc000 = true;
2249   jjtree.openNodeScope(jjtn000);
2250   jjtreeOpenNodeScope(jjtn000);
2251 /*@egen*/}
2252 {/*@bgen(jjtree) ExpressionStatement */
2253         try {
2254 /*@egen*/
2255     Expression() (LOOKAHEAD(2) ";")?/*@bgen(jjtree)*/
2256         } catch (Throwable jjte000) {
2257           if (jjtc000) {
2258             jjtree.clearNodeScope(jjtn000);
2259             jjtc000 = false;
2260           } else {
2261             jjtree.popNode();
2262           }
2263           if (jjte000 instanceof RuntimeException) {
2264             throw (RuntimeException)jjte000;
2265           }
2266           if (jjte000 instanceof ParseException) {
2267             throw (ParseException)jjte000;
2268           }
2269           throw (Error)jjte000;
2270         } finally {
2271           if (jjtc000) {
2272             jjtree.closeNodeScope(jjtn000, true);
2273             jjtreeCloseNodeScope(jjtn000);
2274           }
2275         }
2276 /*@egen*/
2277 }
2278 
2279 /* ECMA-262 5.1 Edition / June 2011 - Section 12.5: The if Statement */
2280 
2281 void IfStatement()              :
2282 {/*@bgen(jjtree) IfStatement */
2283   ECMAIfStatement jjtn000 = new ECMAIfStatement(this, JJTIFSTATEMENT);
2284   boolean jjtc000 = true;
2285   jjtree.openNodeScope(jjtn000);
2286   jjtreeOpenNodeScope(jjtn000);
2287 /*@egen*/}
2288 {/*@bgen(jjtree) IfStatement */
2289         try {
2290 /*@egen*/
2291     "if" "(" Expression() ")" Statement() [ LOOKAHEAD(1) "else" Statement() ]/*@bgen(jjtree)*/
2292         } catch (Throwable jjte000) {
2293           if (jjtc000) {
2294             jjtree.clearNodeScope(jjtn000);
2295             jjtc000 = false;
2296           } else {
2297             jjtree.popNode();
2298           }
2299           if (jjte000 instanceof RuntimeException) {
2300             throw (RuntimeException)jjte000;
2301           }
2302           if (jjte000 instanceof ParseException) {
2303             throw (ParseException)jjte000;
2304           }
2305           throw (Error)jjte000;
2306         } finally {
2307           if (jjtc000) {
2308             jjtree.closeNodeScope(jjtn000, true);
2309             jjtreeCloseNodeScope(jjtn000);
2310           }
2311         }
2312 /*@egen*/
2313 }
2314 
2315 /* ECMA-262 5.1 Edition / June 2011 - Section 12.6: Iteration Statements */
2316 
2317 void IterationStatement()       :
2318 {}
2319 {/*@bgen(jjtree) DoWhileStatement */
2320         {
2321           ECMADoWhileStatement jjtn001 = new ECMADoWhileStatement(this, JJTDOWHILESTATEMENT);
2322           boolean jjtc001 = true;
2323           jjtree.openNodeScope(jjtn001);
2324           jjtreeOpenNodeScope(jjtn001);
2325         }
2326         try {
2327 /*@egen*/
2328     ( "do" Statement() "while" "(" Expression() ")" (LOOKAHEAD(2) ";")? )/*@bgen(jjtree)*/
2329         } catch (Throwable jjte001) {
2330           if (jjtc001) {
2331             jjtree.clearNodeScope(jjtn001);
2332             jjtc001 = false;
2333           } else {
2334             jjtree.popNode();
2335           }
2336           if (jjte001 instanceof RuntimeException) {
2337             throw (RuntimeException)jjte001;
2338           }
2339           if (jjte001 instanceof ParseException) {
2340             throw (ParseException)jjte001;
2341           }
2342           throw (Error)jjte001;
2343         } finally {
2344           if (jjtc001) {
2345             jjtree.closeNodeScope(jjtn001, true);
2346             jjtreeCloseNodeScope(jjtn001);
2347           }
2348         }
2349 /*@egen*/                  
2350 |/*@bgen(jjtree) WhileStatement */
2351         {
2352           ECMAWhileStatement jjtn002 = new ECMAWhileStatement(this, JJTWHILESTATEMENT);
2353           boolean jjtc002 = true;
2354           jjtree.openNodeScope(jjtn002);
2355           jjtreeOpenNodeScope(jjtn002);
2356         }
2357         try {
2358 /*@egen*/   ( "while" "(" Expression() ")" Statement() )/*@bgen(jjtree)*/
2359         } catch (Throwable jjte002) {
2360           if (jjtc002) {
2361             jjtree.clearNodeScope(jjtn002);
2362             jjtc002 = false;
2363           } else {
2364             jjtree.popNode();
2365           }
2366           if (jjte002 instanceof RuntimeException) {
2367             throw (RuntimeException)jjte002;
2368           }
2369           if (jjte002 instanceof ParseException) {
2370             throw (ParseException)jjte002;
2371           }
2372           throw (Error)jjte002;
2373         } finally {
2374           if (jjtc002) {
2375             jjtree.closeNodeScope(jjtn002, true);
2376             jjtreeCloseNodeScope(jjtn002);
2377           }
2378         }
2379 /*@egen*/                
2380 |   LOOKAHEAD("for" "(" (ExpressionNoIn())? ";")/*@bgen(jjtree) ForStatement */
2381                                                      {
2382                                                        ECMAForStatement jjtn006 = new ECMAForStatement(this, JJTFORSTATEMENT);
2383                                                        boolean jjtc006 = true;
2384                                                        jjtree.openNodeScope(jjtn006);
2385                                                        jjtreeOpenNodeScope(jjtn006);
2386                                                      }
2387                                                      try {
2388 /*@egen*/ ( "for" "("/*@bgen(jjtree) #EmptyExpression( jjtree . nodeArity ( ) == 0) */
2389                                                                  {
2390                                                                    ECMAEmptyExpression jjtn003 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2391                                                                    boolean jjtc003 = true;
2392                                                                    jjtree.openNodeScope(jjtn003);
2393                                                                    jjtreeOpenNodeScope(jjtn003);
2394                                                                  }
2395                                                                  try {
2396 /*@egen*/ ( ExpressionNoIn() )?/*@bgen(jjtree)*/
2397                                                                  } catch (Throwable jjte003) {
2398                                                                    if (jjtc003) {
2399                                                                      jjtree.clearNodeScope(jjtn003);
2400                                                                      jjtc003 = false;
2401                                                                    } else {
2402                                                                      jjtree.popNode();
2403                                                                    }
2404                                                                    if (jjte003 instanceof RuntimeException) {
2405                                                                      throw (RuntimeException)jjte003;
2406                                                                    }
2407                                                                    if (jjte003 instanceof ParseException) {
2408                                                                      throw (ParseException)jjte003;
2409                                                                    }
2410                                                                    throw (Error)jjte003;
2411                                                                  } finally {
2412                                                                    if (jjtc003) {
2413                                                                      jjtree.closeNodeScope(jjtn003,  jjtree . nodeArity ( ) == 0);
2414                                                                      jjtreeCloseNodeScope(jjtn003);
2415                                                                    }
2416                                                                  }
2417 /*@egen*/                                         ";"/*@bgen(jjtree) #EmptyExpression( jjtree . nodeArity ( ) == 0) */
2418                                                                                                                                    {
2419                                                                                                                                      ECMAEmptyExpression jjtn004 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2420                                                                                                                                      boolean jjtc004 = true;
2421                                                                                                                                      jjtree.openNodeScope(jjtn004);
2422                                                                                                                                      jjtreeOpenNodeScope(jjtn004);
2423                                                                                                                                    }
2424                                                                                                                                    try {
2425 /*@egen*/ ( Expression() )?/*@bgen(jjtree)*/
2426                                                                                                                                    } catch (Throwable jjte004) {
2427                                                                                                                                      if (jjtc004) {
2428                                                                                                                                        jjtree.clearNodeScope(jjtn004);
2429                                                                                                                                        jjtc004 = false;
2430                                                                                                                                      } else {
2431                                                                                                                                        jjtree.popNode();
2432                                                                                                                                      }
2433                                                                                                                                      if (jjte004 instanceof RuntimeException) {
2434                                                                                                                                        throw (RuntimeException)jjte004;
2435                                                                                                                                      }
2436                                                                                                                                      if (jjte004 instanceof ParseException) {
2437                                                                                                                                        throw (ParseException)jjte004;
2438                                                                                                                                      }
2439                                                                                                                                      throw (Error)jjte004;
2440                                                                                                                                    } finally {
2441                                                                                                                                      if (jjtc004) {
2442                                                                                                                                        jjtree.closeNodeScope(jjtn004,  jjtree . nodeArity ( ) == 0);
2443                                                                                                                                        jjtreeCloseNodeScope(jjtn004);
2444                                                                                                                                      }
2445                                                                                                                                    }
2446 /*@egen*/                                         ";"/*@bgen(jjtree) #EmptyExpression( jjtree . nodeArity ( ) == 0) */
2447                                                                                                                                                                                                  {
2448                                                                                                                                                                                                    ECMAEmptyExpression jjtn005 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2449                                                                                                                                                                                                    boolean jjtc005 = true;
2450                                                                                                                                                                                                    jjtree.openNodeScope(jjtn005);
2451                                                                                                                                                                                                    jjtreeOpenNodeScope(jjtn005);
2452                                                                                                                                                                                                  }
2453                                                                                                                                                                                                  try {
2454 /*@egen*/ ( Expression() )?/*@bgen(jjtree)*/
2455                                                                                                                                                                                                  } catch (Throwable jjte005) {
2456                                                                                                                                                                                                    if (jjtc005) {
2457                                                                                                                                                                                                      jjtree.clearNodeScope(jjtn005);
2458                                                                                                                                                                                                      jjtc005 = false;
2459                                                                                                                                                                                                    } else {
2460                                                                                                                                                                                                      jjtree.popNode();
2461                                                                                                                                                                                                    }
2462                                                                                                                                                                                                    if (jjte005 instanceof RuntimeException) {
2463                                                                                                                                                                                                      throw (RuntimeException)jjte005;
2464                                                                                                                                                                                                    }
2465                                                                                                                                                                                                    if (jjte005 instanceof ParseException) {
2466                                                                                                                                                                                                      throw (ParseException)jjte005;
2467                                                                                                                                                                                                    }
2468                                                                                                                                                                                                    throw (Error)jjte005;
2469                                                                                                                                                                                                  } finally {
2470                                                                                                                                                                                                    if (jjtc005) {
2471                                                                                                                                                                                                      jjtree.closeNodeScope(jjtn005,  jjtree . nodeArity ( ) == 0);
2472                                                                                                                                                                                                      jjtreeCloseNodeScope(jjtn005);
2473                                                                                                                                                                                                    }
2474                                                                                                                                                                                                  }
2475 /*@egen*/                                         ")" Statement() )/*@bgen(jjtree)*/
2476                                                      } catch (Throwable jjte006) {
2477                                                        if (jjtc006) {
2478                                                          jjtree.clearNodeScope(jjtn006);
2479                                                          jjtc006 = false;
2480                                                        } else {
2481                                                          jjtree.popNode();
2482                                                        }
2483                                                        if (jjte006 instanceof RuntimeException) {
2484                                                          throw (RuntimeException)jjte006;
2485                                                        }
2486                                                        if (jjte006 instanceof ParseException) {
2487                                                          throw (ParseException)jjte006;
2488                                                        }
2489                                                        throw (Error)jjte006;
2490                                                      } finally {
2491                                                        if (jjtc006) {
2492                                                          jjtree.closeNodeScope(jjtn006, true);
2493                                                          jjtreeCloseNodeScope(jjtn006);
2494                                                        }
2495                                                      }
2496 /*@egen*/               
2497 |   LOOKAHEAD("for" "(" "var" VariableDeclarationList() ";")/*@bgen(jjtree) ForVarStatement */
2498                                                                  {
2499                                                                    ECMAForVarStatement jjtn009 = new ECMAForVarStatement(this, JJTFORVARSTATEMENT);
2500                                                                    boolean jjtc009 = true;
2501                                                                    jjtree.openNodeScope(jjtn009);
2502                                                                    jjtreeOpenNodeScope(jjtn009);
2503                                                                  }
2504                                                                  try {
2505 /*@egen*/ ( "for" "(" "var" VariableDeclarationList() ";"/*@bgen(jjtree) #EmptyExpression( jjtree . nodeArity ( ) == 0) */
2506                                                                                                                  {
2507                                                                                                                    ECMAEmptyExpression jjtn007 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2508                                                                                                                    boolean jjtc007 = true;
2509                                                                                                                    jjtree.openNodeScope(jjtn007);
2510                                                                                                                    jjtreeOpenNodeScope(jjtn007);
2511                                                                                                                  }
2512                                                                                                                  try {
2513 /*@egen*/ ( Expression() )?/*@bgen(jjtree)*/
2514                                                                                                                  } catch (Throwable jjte007) {
2515                                                                                                                    if (jjtc007) {
2516                                                                                                                      jjtree.clearNodeScope(jjtn007);
2517                                                                                                                      jjtc007 = false;
2518                                                                                                                    } else {
2519                                                                                                                      jjtree.popNode();
2520                                                                                                                    }
2521                                                                                                                    if (jjte007 instanceof RuntimeException) {
2522                                                                                                                      throw (RuntimeException)jjte007;
2523                                                                                                                    }
2524                                                                                                                    if (jjte007 instanceof ParseException) {
2525                                                                                                                      throw (ParseException)jjte007;
2526                                                                                                                    }
2527                                                                                                                    throw (Error)jjte007;
2528                                                                                                                  } finally {
2529                                                                                                                    if (jjtc007) {
2530                                                                                                                      jjtree.closeNodeScope(jjtn007,  jjtree . nodeArity ( ) == 0);
2531                                                                                                                      jjtreeCloseNodeScope(jjtn007);
2532                                                                                                                    }
2533                                                                                                                  }
2534 /*@egen*/                                         ";"/*@bgen(jjtree) #EmptyExpression( jjtree . nodeArity ( ) == 0) */
2535                                                                                                                                                                                {
2536                                                                                                                                                                                  ECMAEmptyExpression jjtn008 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2537                                                                                                                                                                                  boolean jjtc008 = true;
2538                                                                                                                                                                                  jjtree.openNodeScope(jjtn008);
2539                                                                                                                                                                                  jjtreeOpenNodeScope(jjtn008);
2540                                                                                                                                                                                }
2541                                                                                                                                                                                try {
2542 /*@egen*/ ( Expression() )?/*@bgen(jjtree)*/
2543                                                                                                                                                                                } catch (Throwable jjte008) {
2544                                                                                                                                                                                  if (jjtc008) {
2545                                                                                                                                                                                    jjtree.clearNodeScope(jjtn008);
2546                                                                                                                                                                                    jjtc008 = false;
2547                                                                                                                                                                                  } else {
2548                                                                                                                                                                                    jjtree.popNode();
2549                                                                                                                                                                                  }
2550                                                                                                                                                                                  if (jjte008 instanceof RuntimeException) {
2551                                                                                                                                                                                    throw (RuntimeException)jjte008;
2552                                                                                                                                                                                  }
2553                                                                                                                                                                                  if (jjte008 instanceof ParseException) {
2554                                                                                                                                                                                    throw (ParseException)jjte008;
2555                                                                                                                                                                                  }
2556                                                                                                                                                                                  throw (Error)jjte008;
2557                                                                                                                                                                                } finally {
2558                                                                                                                                                                                  if (jjtc008) {
2559                                                                                                                                                                                    jjtree.closeNodeScope(jjtn008,  jjtree . nodeArity ( ) == 0);
2560                                                                                                                                                                                    jjtreeCloseNodeScope(jjtn008);
2561                                                                                                                                                                                  }
2562                                                                                                                                                                                }
2563 /*@egen*/                                         ")" Statement() )/*@bgen(jjtree)*/
2564                                                                  } catch (Throwable jjte009) {
2565                                                                    if (jjtc009) {
2566                                                                      jjtree.clearNodeScope(jjtn009);
2567                                                                      jjtc009 = false;
2568                                                                    } else {
2569                                                                      jjtree.popNode();
2570                                                                    }
2571                                                                    if (jjte009 instanceof RuntimeException) {
2572                                                                      throw (RuntimeException)jjte009;
2573                                                                    }
2574                                                                    if (jjte009 instanceof ParseException) {
2575                                                                      throw (ParseException)jjte009;
2576                                                                    }
2577                                                                    throw (Error)jjte009;
2578                                                                  } finally {
2579                                                                    if (jjtc009) {
2580                                                                      jjtree.closeNodeScope(jjtn009, true);
2581                                                                      jjtreeCloseNodeScope(jjtn009);
2582                                                                    }
2583                                                                  }
2584 /*@egen*/                 
2585 |   LOOKAHEAD("for" "(" "var" VariableDeclarationNoIn() "in")/*@bgen(jjtree) ForVarInStatement */
2586                                                                   {
2587                                                                     ECMAForVarInStatement jjtn010 = new ECMAForVarInStatement(this, JJTFORVARINSTATEMENT);
2588                                                                     boolean jjtc010 = true;
2589                                                                     jjtree.openNodeScope(jjtn010);
2590                                                                     jjtreeOpenNodeScope(jjtn010);
2591                                                                   }
2592                                                                   try {
2593 /*@egen*/ ( "for" "(" "var" VariableDeclarationNoIn() "in" Expression() ")" Statement() )/*@bgen(jjtree)*/
2594                                                                   } catch (Throwable jjte010) {
2595                                                                     if (jjtc010) {
2596                                                                       jjtree.clearNodeScope(jjtn010);
2597                                                                       jjtc010 = false;
2598                                                                     } else {
2599                                                                       jjtree.popNode();
2600                                                                     }
2601                                                                     if (jjte010 instanceof RuntimeException) {
2602                                                                       throw (RuntimeException)jjte010;
2603                                                                     }
2604                                                                     if (jjte010 instanceof ParseException) {
2605                                                                       throw (ParseException)jjte010;
2606                                                                     }
2607                                                                     throw (Error)jjte010;
2608                                                                   } finally {
2609                                                                     if (jjtc010) {
2610                                                                       jjtree.closeNodeScope(jjtn010, true);
2611                                                                       jjtreeCloseNodeScope(jjtn010);
2612                                                                     }
2613                                                                   }
2614 /*@egen*/                   
2615 |/*@bgen(jjtree) ForInStatement */
2616         {
2617           ECMAForInStatement jjtn011 = new ECMAForInStatement(this, JJTFORINSTATEMENT);
2618           boolean jjtc011 = true;
2619           jjtree.openNodeScope(jjtn011);
2620           jjtreeOpenNodeScope(jjtn011);
2621         }
2622         try {
2623 /*@egen*/   ( "for" "(" LeftHandSideExpression() "in" Expression() ")" Statement() )/*@bgen(jjtree)*/
2624         } catch (Throwable jjte011) {
2625           if (jjtc011) {
2626             jjtree.clearNodeScope(jjtn011);
2627             jjtc011 = false;
2628           } else {
2629             jjtree.popNode();
2630           }
2631           if (jjte011 instanceof RuntimeException) {
2632             throw (RuntimeException)jjte011;
2633           }
2634           if (jjte011 instanceof ParseException) {
2635             throw (ParseException)jjte011;
2636           }
2637           throw (Error)jjte011;
2638         } finally {
2639           if (jjtc011) {
2640             jjtree.closeNodeScope(jjtn011, true);
2641             jjtreeCloseNodeScope(jjtn011);
2642           }
2643         }
2644 /*@egen*/                
2645 }
2646 
2647 /* ECMA-262 5.1 Edition / June 2011 - Section 12.7: The continue Statement */
2648 
2649 void ContinueStatement()                    :
2650 {/*@bgen(jjtree) ContinueStatement */
2651   ECMAContinueStatement jjtn000 = new ECMAContinueStatement(this, JJTCONTINUESTATEMENT);
2652   boolean jjtc000 = true;
2653   jjtree.openNodeScope(jjtn000);
2654   jjtreeOpenNodeScope(jjtn000);
2655 /*@egen*/}
2656 {/*@bgen(jjtree) ContinueStatement */
2657         try {
2658 /*@egen*/
2659     "continue" ( LOOKAHEAD(Identifier()) Identifier() )? (LOOKAHEAD(";") ";")?/*@bgen(jjtree)*/
2660         } catch (Throwable jjte000) {
2661           if (jjtc000) {
2662             jjtree.clearNodeScope(jjtn000);
2663             jjtc000 = false;
2664           } else {
2665             jjtree.popNode();
2666           }
2667           if (jjte000 instanceof RuntimeException) {
2668             throw (RuntimeException)jjte000;
2669           }
2670           if (jjte000 instanceof ParseException) {
2671             throw (ParseException)jjte000;
2672           }
2673           throw (Error)jjte000;
2674         } finally {
2675           if (jjtc000) {
2676             jjtree.closeNodeScope(jjtn000, true);
2677             jjtreeCloseNodeScope(jjtn000);
2678           }
2679         }
2680 /*@egen*/
2681 }
2682 
2683 /* ECMA-262 5.1 Edition / June 2011 - Section 12.8: The break Statement */
2684 
2685 void BreakStatement()                 :
2686 {/*@bgen(jjtree) BreakStatement */
2687   ECMABreakStatement jjtn000 = new ECMABreakStatement(this, JJTBREAKSTATEMENT);
2688   boolean jjtc000 = true;
2689   jjtree.openNodeScope(jjtn000);
2690   jjtreeOpenNodeScope(jjtn000);
2691 /*@egen*/}
2692 {/*@bgen(jjtree) BreakStatement */
2693         try {
2694 /*@egen*/
2695     "break" ( LOOKAHEAD(Identifier()) Identifier() )? (LOOKAHEAD(";") ";")?/*@bgen(jjtree)*/
2696         } catch (Throwable jjte000) {
2697           if (jjtc000) {
2698             jjtree.clearNodeScope(jjtn000);
2699             jjtc000 = false;
2700           } else {
2701             jjtree.popNode();
2702           }
2703           if (jjte000 instanceof RuntimeException) {
2704             throw (RuntimeException)jjte000;
2705           }
2706           if (jjte000 instanceof ParseException) {
2707             throw (ParseException)jjte000;
2708           }
2709           throw (Error)jjte000;
2710         } finally {
2711           if (jjtc000) {
2712             jjtree.closeNodeScope(jjtn000, true);
2713             jjtreeCloseNodeScope(jjtn000);
2714           }
2715         }
2716 /*@egen*/
2717 }
2718 
2719 /* ECMA-262 5.1 Edition / June 2011 - Section 12.9 The return Statement */
2720 
2721 void ReturnStatement()                  :
2722 {/*@bgen(jjtree) ReturnStatement */
2723   ECMAReturnStatement jjtn000 = new ECMAReturnStatement(this, JJTRETURNSTATEMENT);
2724   boolean jjtc000 = true;
2725   jjtree.openNodeScope(jjtn000);
2726   jjtreeOpenNodeScope(jjtn000);
2727 /*@egen*/}
2728 {/*@bgen(jjtree) ReturnStatement */
2729         try {
2730 /*@egen*/
2731     "return" ( LOOKAHEAD(Expression()) Expression() )? (LOOKAHEAD(";") ";")?/*@bgen(jjtree)*/
2732         } catch (Throwable jjte000) {
2733           if (jjtc000) {
2734             jjtree.clearNodeScope(jjtn000);
2735             jjtc000 = false;
2736           } else {
2737             jjtree.popNode();
2738           }
2739           if (jjte000 instanceof RuntimeException) {
2740             throw (RuntimeException)jjte000;
2741           }
2742           if (jjte000 instanceof ParseException) {
2743             throw (ParseException)jjte000;
2744           }
2745           throw (Error)jjte000;
2746         } finally {
2747           if (jjtc000) {
2748             jjtree.closeNodeScope(jjtn000, true);
2749             jjtreeCloseNodeScope(jjtn000);
2750           }
2751         }
2752 /*@egen*/
2753 }
2754 
2755 /* ECMA-262 5.1 Edition / June 2011 - Section 12.10: The with Statement */
2756 
2757 void WithStatement()                :
2758 {/*@bgen(jjtree) WithStatement */
2759   ECMAWithStatement jjtn000 = new ECMAWithStatement(this, JJTWITHSTATEMENT);
2760   boolean jjtc000 = true;
2761   jjtree.openNodeScope(jjtn000);
2762   jjtreeOpenNodeScope(jjtn000);
2763 /*@egen*/}
2764 {/*@bgen(jjtree) WithStatement */
2765         try {
2766 /*@egen*/
2767     "with" "(" Expression() ")" Statement()/*@bgen(jjtree)*/
2768         } catch (Throwable jjte000) {
2769           if (jjtc000) {
2770             jjtree.clearNodeScope(jjtn000);
2771             jjtc000 = false;
2772           } else {
2773             jjtree.popNode();
2774           }
2775           if (jjte000 instanceof RuntimeException) {
2776             throw (RuntimeException)jjte000;
2777           }
2778           if (jjte000 instanceof ParseException) {
2779             throw (ParseException)jjte000;
2780           }
2781           throw (Error)jjte000;
2782         } finally {
2783           if (jjtc000) {
2784             jjtree.closeNodeScope(jjtn000, true);
2785             jjtreeCloseNodeScope(jjtn000);
2786           }
2787         }
2788 /*@egen*/
2789 }
2790 
2791 /* ECMA-262 5.1 Edition / June 2011 - 12.11 The switch Statement */
2792 
2793 void SwitchStatement()                  :
2794 {/*@bgen(jjtree) SwitchStatement */
2795   ECMASwitchStatement jjtn000 = new ECMASwitchStatement(this, JJTSWITCHSTATEMENT);
2796   boolean jjtc000 = true;
2797   jjtree.openNodeScope(jjtn000);
2798   jjtreeOpenNodeScope(jjtn000);
2799 /*@egen*/}
2800 {/*@bgen(jjtree) SwitchStatement */
2801         try {
2802 /*@egen*/
2803     "switch" "(" Expression() ")" CaseBlock()/*@bgen(jjtree)*/
2804         } catch (Throwable jjte000) {
2805           if (jjtc000) {
2806             jjtree.clearNodeScope(jjtn000);
2807             jjtc000 = false;
2808           } else {
2809             jjtree.popNode();
2810           }
2811           if (jjte000 instanceof RuntimeException) {
2812             throw (RuntimeException)jjte000;
2813           }
2814           if (jjte000 instanceof ParseException) {
2815             throw (ParseException)jjte000;
2816           }
2817           throw (Error)jjte000;
2818         } finally {
2819           if (jjtc000) {
2820             jjtree.closeNodeScope(jjtn000, true);
2821             jjtreeCloseNodeScope(jjtn000);
2822           }
2823         }
2824 /*@egen*/
2825 }
2826 
2827 void CaseBlock()            :
2828 {/*@bgen(jjtree) CaseBlock */
2829   ECMACaseBlock jjtn000 = new ECMACaseBlock(this, JJTCASEBLOCK);
2830   boolean jjtc000 = true;
2831   jjtree.openNodeScope(jjtn000);
2832   jjtreeOpenNodeScope(jjtn000);
2833 /*@egen*/}
2834 {/*@bgen(jjtree) CaseBlock */
2835         try {
2836 /*@egen*/
2837     "{" ( CaseClauses() )? ( "}" | DefaultClause() ( CaseClauses() )? "}" )/*@bgen(jjtree)*/
2838         } catch (Throwable jjte000) {
2839           if (jjtc000) {
2840             jjtree.clearNodeScope(jjtn000);
2841             jjtc000 = false;
2842           } else {
2843             jjtree.popNode();
2844           }
2845           if (jjte000 instanceof RuntimeException) {
2846             throw (RuntimeException)jjte000;
2847           }
2848           if (jjte000 instanceof ParseException) {
2849             throw (ParseException)jjte000;
2850           }
2851           throw (Error)jjte000;
2852         } finally {
2853           if (jjtc000) {
2854             jjtree.closeNodeScope(jjtn000, true);
2855             jjtreeCloseNodeScope(jjtn000);
2856           }
2857         }
2858 /*@egen*/
2859 }
2860 
2861 void CaseClauses()       :
2862 {}
2863 {
2864     ( CaseClause() )+
2865 }
2866 
2867 void CaseClause()              :
2868 {/*@bgen(jjtree) CaseClause */
2869   ECMACaseClause jjtn000 = new ECMACaseClause(this, JJTCASECLAUSE);
2870   boolean jjtc000 = true;
2871   jjtree.openNodeScope(jjtn000);
2872   jjtreeOpenNodeScope(jjtn000);
2873 /*@egen*/}
2874 {/*@bgen(jjtree) CaseClause */
2875         try {
2876 /*@egen*/
2877     (/*@bgen(jjtree) Case */
2878           {
2879             ECMACase jjtn001 = new ECMACase(this, JJTCASE);
2880             boolean jjtc001 = true;
2881             jjtree.openNodeScope(jjtn001);
2882             jjtreeOpenNodeScope(jjtn001);
2883           }
2884           try {
2885 /*@egen*/ ( "case" Expression() ":" )/*@bgen(jjtree)*/
2886           } catch (Throwable jjte001) {
2887             if (jjtc001) {
2888               jjtree.clearNodeScope(jjtn001);
2889               jjtc001 = false;
2890             } else {
2891               jjtree.popNode();
2892             }
2893             if (jjte001 instanceof RuntimeException) {
2894               throw (RuntimeException)jjte001;
2895             }
2896             if (jjte001 instanceof ParseException) {
2897               throw (ParseException)jjte001;
2898             }
2899             throw (Error)jjte001;
2900           } finally {
2901             if (jjtc001) {
2902               jjtree.closeNodeScope(jjtn001, true);
2903               jjtreeCloseNodeScope(jjtn001);
2904             }
2905           }
2906 /*@egen*/       ) ( StatementList() )?/*@bgen(jjtree)*/
2907         } catch (Throwable jjte000) {
2908           if (jjtc000) {
2909             jjtree.clearNodeScope(jjtn000);
2910             jjtc000 = false;
2911           } else {
2912             jjtree.popNode();
2913           }
2914           if (jjte000 instanceof RuntimeException) {
2915             throw (RuntimeException)jjte000;
2916           }
2917           if (jjte000 instanceof ParseException) {
2918             throw (ParseException)jjte000;
2919           }
2920           throw (Error)jjte000;
2921         } finally {
2922           if (jjtc000) {
2923             jjtree.closeNodeScope(jjtn000, true);
2924             jjtreeCloseNodeScope(jjtn000);
2925           }
2926         }
2927 /*@egen*/
2928 }
2929 
2930 void DefaultClause()             :
2931 {/*@bgen(jjtree) CaseClause */
2932   ECMACaseClause jjtn000 = new ECMACaseClause(this, JJTCASECLAUSE);
2933   boolean jjtc000 = true;
2934   jjtree.openNodeScope(jjtn000);
2935   jjtreeOpenNodeScope(jjtn000);
2936 /*@egen*/}
2937 {/*@bgen(jjtree) CaseClause */
2938         try {
2939 /*@egen*/
2940     (/*@bgen(jjtree) Case */
2941           {
2942             ECMACase jjtn001 = new ECMACase(this, JJTCASE);
2943             boolean jjtc001 = true;
2944             jjtree.openNodeScope(jjtn001);
2945             jjtreeOpenNodeScope(jjtn001);
2946           }
2947           try {
2948 /*@egen*/ ( "default" ":" )/*@bgen(jjtree)*/
2949           } finally {
2950             if (jjtc001) {
2951               jjtree.closeNodeScope(jjtn001, true);
2952               jjtreeCloseNodeScope(jjtn001);
2953             }
2954           }
2955 /*@egen*/       ) ( StatementList() )?/*@bgen(jjtree)*/
2956         } catch (Throwable jjte000) {
2957           if (jjtc000) {
2958             jjtree.clearNodeScope(jjtn000);
2959             jjtc000 = false;
2960           } else {
2961             jjtree.popNode();
2962           }
2963           if (jjte000 instanceof RuntimeException) {
2964             throw (RuntimeException)jjte000;
2965           }
2966           if (jjte000 instanceof ParseException) {
2967             throw (ParseException)jjte000;
2968           }
2969           throw (Error)jjte000;
2970         } finally {
2971           if (jjtc000) {
2972             jjtree.closeNodeScope(jjtn000, true);
2973             jjtreeCloseNodeScope(jjtn000);
2974           }
2975         }
2976 /*@egen*/
2977 }
2978 
2979 /* ECMA-262 5.1 Edition / June 2011 - Section 12.12: Labelled Statements */
2980 
2981 void LabelledStatement()                   :
2982 {/*@bgen(jjtree) LabelledStatement */
2983   ECMALabelledStatement jjtn000 = new ECMALabelledStatement(this, JJTLABELLEDSTATEMENT);
2984   boolean jjtc000 = true;
2985   jjtree.openNodeScope(jjtn000);
2986   jjtreeOpenNodeScope(jjtn000);
2987 /*@egen*/}
2988 {/*@bgen(jjtree) LabelledStatement */
2989         try {
2990 /*@egen*/
2991     Identifier() ":" Statement()/*@bgen(jjtree)*/
2992         } catch (Throwable jjte000) {
2993           if (jjtc000) {
2994             jjtree.clearNodeScope(jjtn000);
2995             jjtc000 = false;
2996           } else {
2997             jjtree.popNode();
2998           }
2999           if (jjte000 instanceof RuntimeException) {
3000             throw (RuntimeException)jjte000;
3001           }
3002           if (jjte000 instanceof ParseException) {
3003             throw (ParseException)jjte000;
3004           }
3005           throw (Error)jjte000;
3006         } finally {
3007           if (jjtc000) {
3008             jjtree.closeNodeScope(jjtn000, true);
3009             jjtreeCloseNodeScope(jjtn000);
3010           }
3011         }
3012 /*@egen*/
3013 }
3014 
3015 void ThrowStatement()                 :
3016 {/*@bgen(jjtree) ThrowStatement */
3017   ECMAThrowStatement jjtn000 = new ECMAThrowStatement(this, JJTTHROWSTATEMENT);
3018   boolean jjtc000 = true;
3019   jjtree.openNodeScope(jjtn000);
3020   jjtreeOpenNodeScope(jjtn000);
3021 /*@egen*/}
3022 {/*@bgen(jjtree) ThrowStatement */
3023         try {
3024 /*@egen*/
3025     "throw" Expression() (LOOKAHEAD(";") ";")?/*@bgen(jjtree)*/
3026         } catch (Throwable jjte000) {
3027           if (jjtc000) {
3028             jjtree.clearNodeScope(jjtn000);
3029             jjtc000 = false;
3030           } else {
3031             jjtree.popNode();
3032           }
3033           if (jjte000 instanceof RuntimeException) {
3034             throw (RuntimeException)jjte000;
3035           }
3036           if (jjte000 instanceof ParseException) {
3037             throw (ParseException)jjte000;
3038           }
3039           throw (Error)jjte000;
3040         } finally {
3041           if (jjtc000) {
3042             jjtree.closeNodeScope(jjtn000, true);
3043             jjtreeCloseNodeScope(jjtn000);
3044           }
3045         }
3046 /*@egen*/
3047 }
3048 
3049 void TryStatement()               : 
3050 {/*@bgen(jjtree) TryStatement */
3051   ECMATryStatement jjtn000 = new ECMATryStatement(this, JJTTRYSTATEMENT);
3052   boolean jjtc000 = true;
3053   jjtree.openNodeScope(jjtn000);
3054   jjtreeOpenNodeScope(jjtn000);
3055 /*@egen*/}
3056 {/*@bgen(jjtree) TryStatement */
3057         try {
3058 /*@egen*/
3059     "try" Block() ( ( Finally() | Catch() [Finally()] ) )/*@bgen(jjtree)*/
3060         } catch (Throwable jjte000) {
3061           if (jjtc000) {
3062             jjtree.clearNodeScope(jjtn000);
3063             jjtc000 = false;
3064           } else {
3065             jjtree.popNode();
3066           }
3067           if (jjte000 instanceof RuntimeException) {
3068             throw (RuntimeException)jjte000;
3069           }
3070           if (jjte000 instanceof ParseException) {
3071             throw (ParseException)jjte000;
3072           }
3073           throw (Error)jjte000;
3074         } finally {
3075           if (jjtc000) {
3076             jjtree.closeNodeScope(jjtn000, true);
3077             jjtreeCloseNodeScope(jjtn000);
3078           }
3079         }
3080 /*@egen*/
3081 }  
3082 
3083 void Catch()        :
3084 {/*@bgen(jjtree) Catch */
3085   ECMACatch jjtn000 = new ECMACatch(this, JJTCATCH);
3086   boolean jjtc000 = true;
3087   jjtree.openNodeScope(jjtn000);
3088   jjtreeOpenNodeScope(jjtn000);
3089 /*@egen*/}
3090 {/*@bgen(jjtree) Catch */
3091         try {
3092 /*@egen*/
3093     "catch" "(" Identifier() ")" Block()/*@bgen(jjtree)*/
3094         } catch (Throwable jjte000) {
3095           if (jjtc000) {
3096             jjtree.clearNodeScope(jjtn000);
3097             jjtc000 = false;
3098           } else {
3099             jjtree.popNode();
3100           }
3101           if (jjte000 instanceof RuntimeException) {
3102             throw (RuntimeException)jjte000;
3103           }
3104           if (jjte000 instanceof ParseException) {
3105             throw (ParseException)jjte000;
3106           }
3107           throw (Error)jjte000;
3108         } finally {
3109           if (jjtc000) {
3110             jjtree.closeNodeScope(jjtn000, true);
3111             jjtreeCloseNodeScope(jjtn000);
3112           }
3113         }
3114 /*@egen*/
3115 }
3116 
3117 void Finally()          :
3118 {/*@bgen(jjtree) Finally */
3119   ECMAFinally jjtn000 = new ECMAFinally(this, JJTFINALLY);
3120   boolean jjtc000 = true;
3121   jjtree.openNodeScope(jjtn000);
3122   jjtreeOpenNodeScope(jjtn000);
3123 /*@egen*/}
3124 {/*@bgen(jjtree) Finally */
3125         try {
3126 /*@egen*/
3127     "finally" Block()/*@bgen(jjtree)*/
3128         } catch (Throwable jjte000) {
3129           if (jjtc000) {
3130             jjtree.clearNodeScope(jjtn000);
3131             jjtc000 = false;
3132           } else {
3133             jjtree.popNode();
3134           }
3135           if (jjte000 instanceof RuntimeException) {
3136             throw (RuntimeException)jjte000;
3137           }
3138           if (jjte000 instanceof ParseException) {
3139             throw (ParseException)jjte000;
3140           }
3141           throw (Error)jjte000;
3142         } finally {
3143           if (jjtc000) {
3144             jjtree.closeNodeScope(jjtn000, true);
3145             jjtreeCloseNodeScope(jjtn000);
3146           }
3147         }
3148 /*@egen*/
3149 }
3150 
3151 /* ECMA-262 5.1 Edition / June 2011 - Section 12.15 The debugger Statement */
3152 
3153 void DebuggerStatement()                    :
3154 {/*@bgen(jjtree) DebuggerStatement */
3155   ECMADebuggerStatement jjtn000 = new ECMADebuggerStatement(this, JJTDEBUGGERSTATEMENT);
3156   boolean jjtc000 = true;
3157   jjtree.openNodeScope(jjtn000);
3158   jjtreeOpenNodeScope(jjtn000);
3159 /*@egen*/}
3160 {/*@bgen(jjtree) DebuggerStatement */
3161         try {
3162 /*@egen*/
3163     "debugger" (LOOKAHEAD(";") ";")?/*@bgen(jjtree)*/
3164         } finally {
3165           if (jjtc000) {
3166             jjtree.closeNodeScope(jjtn000, true);
3167             jjtreeCloseNodeScope(jjtn000);
3168           }
3169         }
3170 /*@egen*/
3171 }
3172 
3173 /* ECMA-262 5.1 Edition / June 2011 - Section 13: Function Definition */
3174 
3175 void FunctionDeclaration()                      :
3176 {/*@bgen(jjtree) FunctionDeclaration */
3177   ECMAFunctionDeclaration jjtn000 = new ECMAFunctionDeclaration(this, JJTFUNCTIONDECLARATION);
3178   boolean jjtc000 = true;
3179   jjtree.openNodeScope(jjtn000);
3180   jjtreeOpenNodeScope(jjtn000);
3181 /*@egen*/}
3182 {/*@bgen(jjtree) FunctionDeclaration */
3183         try {
3184 /*@egen*/
3185     "function" Identifier()/*@bgen(jjtree) FormalParameterList */
3186                                 {
3187                                   ECMAFormalParameterList jjtn001 = new ECMAFormalParameterList(this, JJTFORMALPARAMETERLIST);
3188                                   boolean jjtc001 = true;
3189                                   jjtree.openNodeScope(jjtn001);
3190                                   jjtreeOpenNodeScope(jjtn001);
3191                                 }
3192                                 try {
3193 /*@egen*/ ( "(" ( FormalParameterList() )? ")" )/*@bgen(jjtree)*/
3194                                 } catch (Throwable jjte001) {
3195                                   if (jjtc001) {
3196                                     jjtree.clearNodeScope(jjtn001);
3197                                     jjtc001 = false;
3198                                   } else {
3199                                     jjtree.popNode();
3200                                   }
3201                                   if (jjte001 instanceof RuntimeException) {
3202                                     throw (RuntimeException)jjte001;
3203                                   }
3204                                   if (jjte001 instanceof ParseException) {
3205                                     throw (ParseException)jjte001;
3206                                   }
3207                                   throw (Error)jjte001;
3208                                 } finally {
3209                                   if (jjtc001) {
3210                                     jjtree.closeNodeScope(jjtn001, true);
3211                                     jjtreeCloseNodeScope(jjtn001);
3212                                   }
3213                                 }
3214 /*@egen*/                      FunctionBody()/*@bgen(jjtree)*/
3215         } catch (Throwable jjte000) {
3216           if (jjtc000) {
3217             jjtree.clearNodeScope(jjtn000);
3218             jjtc000 = false;
3219           } else {
3220             jjtree.popNode();
3221           }
3222           if (jjte000 instanceof RuntimeException) {
3223             throw (RuntimeException)jjte000;
3224           }
3225           if (jjte000 instanceof ParseException) {
3226             throw (ParseException)jjte000;
3227           }
3228           throw (Error)jjte000;
3229         } finally {
3230           if (jjtc000) {
3231             jjtree.closeNodeScope(jjtn000, true);
3232             jjtreeCloseNodeScope(jjtn000);
3233           }
3234         }
3235 /*@egen*/  
3236 }
3237 
3238 void FunctionExpression()                     :
3239 {/*@bgen(jjtree) FunctionExpression */
3240   ECMAFunctionExpression jjtn000 = new ECMAFunctionExpression(this, JJTFUNCTIONEXPRESSION);
3241   boolean jjtc000 = true;
3242   jjtree.openNodeScope(jjtn000);
3243   jjtreeOpenNodeScope(jjtn000);
3244 /*@egen*/}
3245 {/*@bgen(jjtree) FunctionExpression */
3246         try {
3247 /*@egen*/
3248     "function" ( Identifier() )?/*@bgen(jjtree) FormalParameterList */
3249                                      {
3250                                        ECMAFormalParameterList jjtn001 = new ECMAFormalParameterList(this, JJTFORMALPARAMETERLIST);
3251                                        boolean jjtc001 = true;
3252                                        jjtree.openNodeScope(jjtn001);
3253                                        jjtreeOpenNodeScope(jjtn001);
3254                                      }
3255                                      try {
3256 /*@egen*/ ( "(" ( FormalParameterList() )? ")" )/*@bgen(jjtree)*/
3257                                      } catch (Throwable jjte001) {
3258                                        if (jjtc001) {
3259                                          jjtree.clearNodeScope(jjtn001);
3260                                          jjtc001 = false;
3261                                        } else {
3262                                          jjtree.popNode();
3263                                        }
3264                                        if (jjte001 instanceof RuntimeException) {
3265                                          throw (RuntimeException)jjte001;
3266                                        }
3267                                        if (jjte001 instanceof ParseException) {
3268                                          throw (ParseException)jjte001;
3269                                        }
3270                                        throw (Error)jjte001;
3271                                      } finally {
3272                                        if (jjtc001) {
3273                                          jjtree.closeNodeScope(jjtn001, true);
3274                                          jjtreeCloseNodeScope(jjtn001);
3275                                        }
3276                                      }
3277 /*@egen*/                      FunctionBody()/*@bgen(jjtree)*/
3278         } catch (Throwable jjte000) {
3279           if (jjtc000) {
3280             jjtree.clearNodeScope(jjtn000);
3281             jjtc000 = false;
3282           } else {
3283             jjtree.popNode();
3284           }
3285           if (jjte000 instanceof RuntimeException) {
3286             throw (RuntimeException)jjte000;
3287           }
3288           if (jjte000 instanceof ParseException) {
3289             throw (ParseException)jjte000;
3290           }
3291           throw (Error)jjte000;
3292         } finally {
3293           if (jjtc000) {
3294             jjtree.closeNodeScope(jjtn000, true);
3295             jjtreeCloseNodeScope(jjtn000);
3296           }
3297         }
3298 /*@egen*/
3299 }
3300 
3301 void FormalParameterList()       :
3302 {}
3303 {
3304     Identifier() ( "," Identifier() )*
3305 }
3306 
3307 void FunctionBody()        :
3308 {/*@bgen(jjtree) Block */
3309   ECMABlock jjtn000 = new ECMABlock(this, JJTBLOCK);
3310   boolean jjtc000 = true;
3311   jjtree.openNodeScope(jjtn000);
3312   jjtreeOpenNodeScope(jjtn000);
3313 /*@egen*/}
3314 {/*@bgen(jjtree) Block */
3315         try {
3316 /*@egen*/
3317     "{" (SourceElements())? "}"/*@bgen(jjtree)*/
3318         } catch (Throwable jjte000) {
3319           if (jjtc000) {
3320             jjtree.clearNodeScope(jjtn000);
3321             jjtc000 = false;
3322           } else {
3323             jjtree.popNode();
3324           }
3325           if (jjte000 instanceof RuntimeException) {
3326             throw (RuntimeException)jjte000;
3327           }
3328           if (jjte000 instanceof ParseException) {
3329             throw (ParseException)jjte000;
3330           }
3331           throw (Error)jjte000;
3332         } finally {
3333           if (jjtc000) {
3334             jjtree.closeNodeScope(jjtn000, true);
3335             jjtreeCloseNodeScope(jjtn000);
3336           }
3337         }
3338 /*@egen*/ 
3339 }
3340 
3341 /* ECMA-262 5.1 Edition / June 2011 - Section 14: Script */
3342 
3343 ECMAProgram Program()          :
3344 {/*@bgen(jjtree) Program */
3345   ECMAProgram jjtn000 = new ECMAProgram(this, JJTPROGRAM);
3346   boolean jjtc000 = true;
3347   jjtree.openNodeScope(jjtn000);
3348   jjtreeOpenNodeScope(jjtn000);
3349 /*@egen*/}
3350 {/*@bgen(jjtree) Program */
3351         try {
3352 /*@egen*/  
3353     (SourceElements())? <EOF>/*@bgen(jjtree)*/
3354         {
3355           jjtree.closeNodeScope(jjtn000, true);
3356           jjtc000 = false;
3357           jjtreeCloseNodeScope(jjtn000);
3358         }
3359 /*@egen*/
3360     {
3361         return jjtn000;
3362     }/*@bgen(jjtree)*/
3363         } catch (Throwable jjte000) {
3364           if (jjtc000) {
3365             jjtree.clearNodeScope(jjtn000);
3366             jjtc000 = false;
3367           } else {
3368             jjtree.popNode();
3369           }
3370           if (jjte000 instanceof RuntimeException) {
3371             throw (RuntimeException)jjte000;
3372           }
3373           if (jjte000 instanceof ParseException) {
3374             throw (ParseException)jjte000;
3375           }
3376           throw (Error)jjte000;
3377         } finally {
3378           if (jjtc000) {
3379             jjtree.closeNodeScope(jjtn000, true);
3380             jjtreeCloseNodeScope(jjtn000);
3381           }
3382         }
3383 /*@egen*/
3384 }
3385 
3386 void SourceElements()       :
3387 {}
3388 {
3389     (SourceElement())+ 
3390 }
3391 
3392 void SourceElement()       :
3393 {}
3394 {
3395     LOOKAHEAD(FunctionDeclaration()) FunctionDeclaration()
3396 |   Statement()
3397 }
3398 
3399 /* ECMA-262 5.1 Edition / June 2011 - Section 7.6: Identifiers */
3400 
3401 void Identifier()             :
3402 {/*@bgen(jjtree) Identifier */
3403         ECMAIdentifier jjtn000 = new ECMAIdentifier(this, JJTIDENTIFIER);
3404         boolean jjtc000 = true;
3405         jjtree.openNodeScope(jjtn000);
3406         jjtreeOpenNodeScope(jjtn000);
3407 /*@egen*/
3408     Token t;
3409 }
3410 {/*@bgen(jjtree) Identifier */
3411         try {
3412 /*@egen*/
3413     t = < IDENTIFIER_NAME >/*@bgen(jjtree)*/
3414         {
3415           jjtree.closeNodeScope(jjtn000, true);
3416           jjtc000 = false;
3417           jjtreeCloseNodeScope(jjtn000);
3418         }
3419 /*@egen*/
3420     {
3421         jjtn000.jjtSetValue(t.image);
3422     }/*@bgen(jjtree)*/
3423         } finally {
3424           if (jjtc000) {
3425             jjtree.closeNodeScope(jjtn000, true);
3426             jjtreeCloseNodeScope(jjtn000);
3427           }
3428         }
3429 /*@egen*/
3430 }
3431 
3432 TOKEN:
3433 {
3434     < IDENTIFIER_NAME: <IDENTIFIER_START> (<IDENTIFIER_PART>)* >
3435 |
3436     < #IDENTIFIER_START:
3437         <UNICODE_LETTER>
3438     | 
3439         <DOLLAR_SIGN>
3440     | 
3441         <UNDER_SCORE>
3442     | 
3443         <UNICODE_ESCAPE_SEQUENCE>
3444     >
3445 |
3446     < #IDENTIFIER_PART: 
3447         <IDENTIFIER_START>
3448     | 
3449         <UNICODE_COMBINING_MARK>
3450     | 
3451         <UNICODE_DIGIT>
3452     | 
3453         <UNICODE_CONNECTOR_PUNCTUATION>
3454     | 
3455         <UNICODE_ESCAPE_SEQUENCE>
3456     >
3457 |
3458     < #DOLLAR_SIGN: "$" >
3459 |  
3460     < #UNDER_SCORE: "_" >
3461 |
3462     < #UNICODE_LETTER: 
3463         ["A"-"Z"]
3464     |   ["a"-"z"]
3465     |   ["A"-"Z"] 
3466     |   ["a"-"z"] 
3467     |   ["\u00aa"] 
3468     |   ["\u00b5"]
3469     |   ["\u00ba"] 
3470     |   ["\u00c0"-"\u00d6"] 
3471     |   ["\u00d8"-"\u00f6"] 
3472     |   ["\u00f8"-"\u021f"]
3473     |   ["\u0222"-"\u0233"] 
3474     |   ["\u0250"-"\u02ad"] 
3475     |   ["\u02b0"-"\u02b8"] 
3476     |   ["\u02bb"-"\u02c1"]
3477     |   ["\u02d0"-"\u02d1"] 
3478     |   ["\u02e0"-"\u02e4"] 
3479     |   ["\u02ee"] 
3480     |   ["\u037a"]
3481     |   ["\u0386"] 
3482     |   ["\u0388"-"\u038a"]
3483     |   ["\u038c"]
3484     |   ["\u038e"-"\u03a1"]
3485     |   ["\u03a3"-"\u03ce"] 
3486     |   ["\u03d0"-"\u03d7"] 
3487     |   ["\u03da"-"\u03f3"]
3488     |   ["\u0400"-"\u0481"]
3489     |   ["\u048c"-"\u04c4"]
3490     |   ["\u04c7"-"\u04c8"]
3491     |   ["\u04cb"-"\u04cc"] 
3492     |   ["\u04d0"-"\u04f5"]
3493     |   ["\u04f8"-"\u04f9"]
3494     |   ["\u0531"-"\u0556"]
3495     |   ["\u0559"]
3496     |   ["\u0561"-"\u0587"]
3497     |   ["\u05d0"-"\u05ea"]
3498     |   ["\u05f0"-"\u05f2"] 
3499     |   ["\u0621"-"\u063a"] 
3500     |   ["\u0640"-"\u064a"]
3501     |   ["\u0671"-"\u06d3"]
3502     |   ["\u06d5"] 
3503     |   ["\u06e5"-"\u06e6"] 
3504     |   ["\u06fa"-"\u06fc"]
3505     |   ["\u0710"] 
3506     |   ["\u0712"-"\u072c"] 
3507     |   ["\u0780"-"\u07a5"] 
3508     |   ["\u0905"-"\u0939"]
3509     |   ["\u093d"] 
3510     |   ["\u0950"] 
3511     |   ["\u0958"-"\u0961"] 
3512     |   ["\u0985"-"\u098c"]
3513     |   ["\u098f"-"\u0990"] 
3514     |   ["\u0993"-"\u09a8"] 
3515     |   ["\u09aa"-"\u09b0"] 
3516     |   ["\u09b2"]
3517     |   ["\u09b6"-"\u09b9"] 
3518     |   ["\u09dc"-"\u09dd"] 
3519     |   ["\u09df"-"\u09e1"] 
3520     |   ["\u09f0"-"\u09f1"]
3521     |   ["\u0a05"-"\u0a0a"] 
3522     |   ["\u0a0f"-"\u0a10"] 
3523     |   ["\u0a13"-"\u0a28"] 
3524     |   ["\u0a2a"-"\u0a30"]
3525     |   ["\u0a32"-"\u0a33"] 
3526     |   ["\u0a35"-"\u0a36"] 
3527     |   ["\u0a38"-"\u0a39"] 
3528     |   ["\u0a59"-"\u0a5c"]
3529     |   ["\u0a5e"] 
3530     |   ["\u0a72"-"\u0a74"] 
3531     |   ["\u0a85"-"\u0a8b"] 
3532     |   ["\u0a8d"]
3533     |   ["\u0a8f"-"\u0a91"] 
3534     |   ["\u0a93"-"\u0aa8"] 
3535     |   ["\u0aaa"-"\u0ab0"] 
3536     |   ["\u0ab2"-"\u0ab3"]
3537     |   ["\u0ab5"-"\u0ab9"] 
3538     |   ["\u0abd"] 
3539     |   ["\u0ad0"] 
3540     |   ["\u0ae0"]
3541     |   ["\u0b05"-"\u0b0c"] 
3542     |   ["\u0b0f"-"\u0b10"] 
3543     |   ["\u0b13"-"\u0b28"] 
3544     |   ["\u0b2a"-"\u0b30"]
3545     |   ["\u0b32"-"\u0b33"] 
3546     |   ["\u0b36"-"\u0b39"] 
3547     |   ["\u0b3d"] 
3548     |   ["\u0b5c"-"\u0b5d"]
3549     |   ["\u0b5f"-"\u0b61"] 
3550     |   ["\u0b85"-"\u0b8a"]
3551     |   ["\u0b8e"-"\u0b90"] 
3552     |   ["\u0b92"-"\u0b95"]
3553     |   ["\u0b99"-"\u0b9a"] 
3554     |   ["\u0b9c"] 
3555     |   ["\u0b9e"-"\u0b9f"] 
3556     |   ["\u0ba3"-"\u0ba4"]
3557     |   ["\u0ba8"-"\u0baa"] 
3558     |   ["\u0bae"-"\u0bb5"] 
3559     |   ["\u0bb7"-"\u0bb9"] 
3560     |   ["\u0c05"-"\u0c0c"]
3561     |   ["\u0c0e"-"\u0c10"] 
3562     |   ["\u0c12"-"\u0c28"]
3563     |   ["\u0c2a"-"\u0c33"]
3564     |   ["\u0c35"-"\u0c39"]
3565     |   ["\u0c60"-"\u0c61"]
3566     |   ["\u0c85"-"\u0c8c"]
3567     |   ["\u0c8e"-"\u0c90"]
3568     |   ["\u0c92"-"\u0ca8"]
3569     |   ["\u0caa"-"\u0cb3"]
3570     |   ["\u0cb5"-"\u0cb9"]
3571     |   ["\u0cde"]
3572     |   ["\u0ce0"-"\u0ce1"]
3573     |   ["\u0d05"-"\u0d0c"]
3574     |   ["\u0d0e"-"\u0d10"]
3575     |   ["\u0d12"-"\u0d28"]
3576     |   ["\u0d2a"-"\u0d39"]
3577     |   ["\u0d60"-"\u0d61"]
3578     |   ["\u0d85"-"\u0d96"]
3579     |   ["\u0d9a"-"\u0db1"]
3580     |   ["\u0db3"-"\u0dbb"]
3581     |   ["\u0dbd"]
3582     |   ["\u0dc0"-"\u0dc6"]
3583     |   ["\u0e01"-"\u0e30"]
3584     |   ["\u0e32"-"\u0e33"]
3585     |   ["\u0e40"-"\u0e46"]
3586     |   ["\u0e81"-"\u0e82"]
3587     |   ["\u0e84"]
3588     |   ["\u0e87"-"\u0e88"]
3589     |   ["\u0e8a"]
3590     |   ["\u0e8d"]
3591     |   ["\u0e94"-"\u0e97"]
3592     |   ["\u0e99"-"\u0e9f"]
3593     |   ["\u0ea1"-"\u0ea3"]
3594     |   ["\u0ea5"]
3595     |   ["\u0ea7"]
3596     |   ["\u0eaa"-"\u0eab"]
3597     |   ["\u0ead"-"\u0eb0"]
3598     |   ["\u0eb2"-"\u0eb3"]
3599     |   ["\u0ebd"-"\u0ec4"]
3600     |   ["\u0ec6"]
3601     |   ["\u0edc"-"\u0edd"]
3602     |   ["\u0f00"]
3603     |   ["\u0f40"-"\u0f6a"]
3604     |   ["\u0f88"-"\u0f8b"]
3605     |   ["\u1000"-"\u1021"]
3606     |   ["\u1023"-"\u1027"]
3607     |   ["\u1029"-"\u102a"]
3608     |   ["\u1050"-"\u1055"]
3609     |   ["\u10a0"-"\u10c5"]
3610     |   ["\u10d0"-"\u10f6"]
3611     |   ["\u1100"-"\u1159"]
3612     |   ["\u115f"-"\u11a2"]
3613     |   ["\u11a8"-"\u11f9"]
3614     |   ["\u1200"-"\u1206"]
3615     |   ["\u1208"-"\u1246"]
3616     |   ["\u1248"]
3617     |   ["\u124a"-"\u124d"]
3618     |   ["\u1250"-"\u1256"]
3619     |   ["\u1258"]
3620     |   ["\u125a"-"\u125d"]
3621     |   ["\u1260"-"\u1286"]
3622     |   ["\u1288"]
3623     |   ["\u128a"-"\u128d"]
3624     |   ["\u1290"-"\u12ae"]
3625     |   ["\u12b0"]
3626     |   ["\u12b2"-"\u12b5"]
3627     |   ["\u12b8"-"\u12be"]
3628     |   ["\u12c0"]
3629     |   ["\u12c2"-"\u12c5"]
3630     |   ["\u12c8"-"\u12ce"]
3631     |   ["\u12d0"-"\u12d6"]
3632     |   ["\u12d8"-"\u12ee"]
3633     |   ["\u12f0"-"\u130e"]
3634     |   ["\u1310"]
3635     |   ["\u1312"-"\u1315"]
3636     |   ["\u1318"-"\u131e"]
3637     |   ["\u1320"-"\u1346"]
3638     |   ["\u1348"-"\u135a"]
3639     |   ["\u13a0"-"\u13b0"]
3640     |   ["\u13b1"-"\u13f4"]
3641     |   ["\u1401"-"\u1676"]
3642     |   ["\u1681"-"\u169a"]
3643     |   ["\u16a0"-"\u16ea"]
3644     |   ["\u1780"-"\u17b3"]
3645     |   ["\u1820"-"\u1877"]
3646     |   ["\u1880"-"\u18a8"]
3647     |   ["\u1e00"-"\u1e9b"]
3648     |   ["\u1ea0"-"\u1ee0"]
3649     |   ["\u1ee1"-"\u1ef9"]
3650     |   ["\u1f00"-"\u1f15"]
3651     |   ["\u1f18"-"\u1f1d"]
3652     |   ["\u1f20"-"\u1f39"]
3653     |   ["\u1f3a"-"\u1f45"]
3654     |   ["\u1f48"-"\u1f4d"]
3655     |   ["\u1f50"-"\u1f57"]
3656     |   ["\u1f59"]
3657     |   ["\u1f5b"]
3658     |   ["\u1f5d"]
3659     |   ["\u1f5f"-"\u1f7d"]
3660     |   ["\u1f80"-"\u1fb4"]
3661     |   ["\u1fb6"-"\u1fbc"]
3662     |   ["\u1fbe"]
3663     |   ["\u1fc2"-"\u1fc4"]
3664     |   ["\u1fc6"-"\u1fcc"]
3665     |   ["\u1fd0"-"\u1fd3"]
3666     |   ["\u1fd6"-"\u1fdb"]
3667     |   ["\u1fe0"-"\u1fec"]
3668     |   ["\u1ff2"-"\u1ff4"]
3669     |   ["\u1ff6"-"\u1ffc"]
3670     |   ["\u207f"]
3671     |   ["\u2102"]
3672     |   ["\u2107"]
3673     |   ["\u210a"-"\u2113"]
3674     |   ["\u2115"]
3675     |   ["\u2119"-"\u211d"]
3676     |   ["\u2124"]
3677     |   ["\u2126"]
3678     |   ["\u2128"]
3679     |   ["\u212a"-"\u212d"]
3680     |   ["\u212f"-"\u2131"]
3681     |   ["\u2133"-"\u2139"]
3682     |   ["\u2160"-"\u2183"]
3683     |   ["\u3005"-"\u3007"]
3684     |   ["\u3021"-"\u3029"]
3685     |   ["\u3031"-"\u3035"]
3686     |   ["\u3038"-"\u303a"]
3687     |   ["\u3041"-"\u3094"]
3688     |   ["\u309d"-"\u309e"]
3689     |   ["\u30a1"-"\u30fa"]
3690     |   ["\u30fc"-"\u30fe"]
3691     |   ["\u3105"-"\u312c"]
3692     |   ["\u3131"-"\u318e"]
3693     |   ["\u31a0"-"\u31b7"]
3694     |   ["\u3400"]
3695     |   ["\u4db5"]
3696     |   ["\u4e00"]
3697     |   ["\u9fa5"]
3698     |   ["\ua000"-"\ua48c"]
3699     |   ["\uac00"]
3700     |   ["\ud7a3"]
3701     |   ["\uf900"-"\ufa2d"]
3702     |   ["\ufb00"-"\ufb06"]
3703     |   ["\ufb13"-"\ufb17"]
3704     |   ["\ufb1d"]
3705     |   ["\ufb1f"-"\ufb28"]
3706     |   ["\ufb2a"-"\ufb36"]
3707     |   ["\ufb38"-"\ufb3c"]
3708     |   ["\ufb3e"]
3709     |   ["\ufb40"-"\ufb41"]
3710     |   ["\ufb43"-"\ufb44"]
3711     |   ["\ufb46"-"\ufbb1"]
3712     |   ["\ufbd3"-"\ufd3d"]
3713     |   ["\ufd50"-"\ufd8f"]
3714     |   ["\ufd92"-"\ufdc7"]
3715     |   ["\ufdf0"-"\ufdfb"]
3716     |   ["\ufe70"-"\ufe72"]
3717     |   ["\ufe74"]
3718     |   ["\ufe76"-"\ufefc"]
3719     |   ["\uff21"-"\uff3a"]
3720     |   ["\uff41"-"\uff5a"]
3721     |   ["\uff66"-"\uffbe"]
3722     |   ["\uffc2"-"\uffc7"]
3723     |   ["\uffca"-"\uffcf"]
3724     |   ["\uffd2"-"\uffd7"]
3725     |   ["\uffda"-"\uffdc"]
3726     >
3727 } 
3728 
3729 /*
3730  * Unicode categories Non-spacing mark (MN) OR Combining spacing mark (MC)
3731  */
3732 MORE:
3733 {
3734     < UNICODE_COMBINING_MARK: <MN> | <MC> >
3735 }
3736 
3737 
3738 TOKEN:
3739 {
3740     < MC: 
3741         ["\u0903"]
3742     |   ["\u093e"]
3743     |   ["\u093f"]
3744     |   ["\u0940"]
3745     |   ["\u0949"]
3746     |   ["\u094a"]
3747     |   ["\u094b"]
3748     |   ["\u094c"]
3749     |   ["\u0982"]
3750     |   ["\u0983"]
3751     |   ["\u09be"]
3752     |   ["\u09bf"]
3753     |   ["\u09c0"]
3754     |   ["\u09c7"]
3755     |   ["\u09c8"]
3756     |   ["\u09cb"]
3757     |   ["\u09cc"]
3758     |   ["\u09d7"]
3759     |   ["\u0a03"]
3760     |   ["\u0a3e"]
3761     |   ["\u0a3f"]
3762     |   ["\u0a40"]
3763     |   ["\u0a83"]
3764     |   ["\u0abe"]
3765     |   ["\u0abf"]
3766     |   ["\u0ac0"]
3767     |   ["\u0ac9"]
3768     |   ["\u0acb"]
3769     |   ["\u0acc"]
3770     |   ["\u0b02"]
3771     |   ["\u0b03"]
3772     |   ["\u0b3e"]
3773     |   ["\u0b40"]
3774     |   ["\u0b47"]
3775     |   ["\u0b48"]
3776     |   ["\u0b4b"]
3777     |   ["\u0b4c"]
3778     |   ["\u0b57"]
3779     |   ["\u0bbe"]
3780     |   ["\u0bbf"]
3781     |   ["\u0bc1"]
3782     |   ["\u0bc2"]
3783     |   ["\u0bc6"]
3784     |   ["\u0bc7"]
3785     |   ["\u0bc8"]
3786     |   ["\u0bca"]
3787     |   ["\u0bcb"]
3788     |   ["\u0bcc"]
3789     |   ["\u0bd7"]
3790     |   ["\u0c01"]
3791     |   ["\u0c02"]
3792     |   ["\u0c03"]
3793     |   ["\u0c41"]
3794     |   ["\u0c42"]
3795     |   ["\u0c43"]
3796     |   ["\u0c44"]
3797     |   ["\u0c82"]
3798     |   ["\u0c83"]
3799     |   ["\u0cbe"]
3800     |   ["\u0cc0"]
3801     |   ["\u0cc1"]
3802     |   ["\u0cc2"]
3803     |   ["\u0cc3"]
3804     |   ["\u0cc4"]
3805     |   ["\u0cc7"]
3806     |   ["\u0cc8"]
3807     |   ["\u0cca"]
3808     |   ["\u0ccb"]
3809     |   ["\u0cd5"]
3810     |   ["\u0cd6"]
3811     |   ["\u0d02"]
3812     |   ["\u0d03"]
3813     |   ["\u0d3e"]
3814     |   ["\u0d3f"]
3815     |   ["\u0d40"]
3816     |   ["\u0d46"]
3817     |   ["\u0d47"]
3818     |   ["\u0d48"]
3819     |   ["\u0d4a"]
3820     |   ["\u0d4b"]
3821     |   ["\u0d4c"]
3822     |   ["\u0d57"]
3823     |   ["\u0d82"]
3824     |   ["\u0d83"]
3825     |   ["\u0dcf"]
3826     |   ["\u0dd0"]
3827     |   ["\u0dd1"]
3828     |   ["\u0dd8"]
3829     |   ["\u0dd9"]
3830     |   ["\u0dda"]
3831     |   ["\u0ddb"]
3832     |   ["\u0ddc"]
3833     |   ["\u0ddd"]
3834     |   ["\u0dde"]
3835     |   ["\u0ddf"]
3836     |   ["\u0df2"]
3837     |   ["\u0df3"]
3838     |   ["\u0f3e"]
3839     |   ["\u0f3f"]
3840     |   ["\u0f7f"]
3841     |   ["\u102c"]
3842     |   ["\u1031"]
3843     |   ["\u1038"]
3844     |   ["\u1056"]
3845     |   ["\u1057"]
3846     |   ["\u17b6"]
3847     |   ["\u17be"]
3848     |   ["\u17bf"]
3849     |   ["\u17c0"]
3850     |   ["\u17c1"]
3851     |   ["\u17c2"]
3852     |   ["\u17c3"]
3853     |   ["\u17c4"]
3854     |   ["\u17c5"]
3855     |   ["\u17c7"]
3856     |   ["\u17c8"]
3857     |   ["\u1923"]
3858     |   ["\u1924"]
3859     |   ["\u1925"]
3860     |   ["\u1926"]
3861     |   ["\u1929"]
3862     |   ["\u192a"]
3863     |   ["\u192b"]
3864     |   ["\u1930"]
3865     |   ["\u1931"]
3866     |   ["\u1933"]
3867     |   ["\u1934"]
3868     |   ["\u1935"]
3869     |   ["\u1936"]
3870     |   ["\u1937"]
3871     |   ["\u1938"]
3872     |   ["\u19b0"]
3873     |   ["\u19b1"]
3874     |   ["\u19b2"]
3875     |   ["\u19b3"]
3876     |   ["\u19b4"]
3877     |   ["\u19b5"]
3878     |   ["\u19b6"]
3879     |   ["\u19b7"]
3880     |   ["\u19b8"]
3881     |   ["\u19b9"]
3882     |   ["\u19ba"]
3883     |   ["\u19bb"]
3884     |   ["\u19bc"]
3885     |   ["\u19bd"]
3886     |   ["\u19be"]
3887     |   ["\u19bf"]
3888     |   ["\u19c0"]
3889     |   ["\u19c8"]
3890     |   ["\u19c9"]
3891     |   ["\u1a19"]
3892     |   ["\u1a1a"]
3893     |   ["\u1a1b"]
3894     |   ["\ua802"]
3895     |   ["\ua823"]
3896     |   ["\ua824"]
3897     |   ["\ua827"]
3898     |   ["\u1d16"]
3899     |   ["\u1d16"]
3900     |   ["\u1d16"]
3901     |   ["\u1d16"]
3902     |   ["\u1d16"]
3903     |   ["\u1d17"]
3904     |   ["\u1d17"]
3905     |   ["\u1d17"] 
3906     >
3907 |   < MN: 
3908         ["\u0300"-"\u034e"] 
3909     |   ["\u0360"-"\u0362"] 
3910     |   ["\u0483"-"\u0486"] 
3911     |   ["\u0591"-"\u05a1"]
3912     |   ["\u05a3"-"\u05b9"] 
3913     |   ["\u05bb"-"\u05bd"] 
3914     |   ["\u05bf"]
3915     |   ["\u05c1"-"\u05c2"]
3916     |   ["\u05c4"]
3917     |   ["\u064b"-"\u0655"] 
3918     |   ["\u0670"]
3919     |   ["\u06d6"-"\u06dc"]
3920     |   ["\u06df"-"\u06e4"] 
3921     |   ["\u06e7"-"\u06e8"] 
3922     |   ["\u06ea"-"\u06ed"] 
3923     |   ["\u0711"]
3924     |   ["\u0730"-"\u074a"] 
3925     |   ["\u07a6"-"\u07b0"] 
3926     |   ["\u0901"-"\u0903"] 
3927     |   ["\u093c"]
3928     |   ["\u093e"-"\u094d"] 
3929     |   ["\u0951"-"\u0954"] 
3930     |   ["\u0962"-"\u0963"] 
3931     |   ["\u0981"-"\u0983"]
3932     |   ["\u09bc"-"\u09c4"] 
3933     |   ["\u09c7"-"\u09c8"] 
3934     |   ["\u09cb"-"\u09cd"] 
3935     |   ["\u09d7"]
3936     |   ["\u09e2"-"\u09e3"] 
3937     |   ["\u0a02"]
3938     |   ["\u0a3c"]
3939     |   ["\u0a3e"-"\u0a42"]
3940     |   ["\u0a47"-"\u0a48"] 
3941     |   ["\u0a4b"-"\u0a4d"] 
3942     |   ["\u0a70"-"\u0a71"] 
3943     |   ["\u0a81"-"\u0a83"]
3944     |   ["\u0abc"]
3945     |   ["\u0abe"-"\u0ac5"] 
3946     |   ["\u0ac7"-"\u0ac9"] 
3947     |   ["\u0acb"-"\u0acd"]
3948     |   ["\u0b01"-"\u0b03"] 
3949     |   ["\u0b3c"]
3950     |   ["\u0b3e"-"\u0b43"] 
3951     |   ["\u0b47"-"\u0b48"]
3952     |   ["\u0b4b"-"\u0b4d"] 
3953     |   ["\u0b56"-"\u0b57"] 
3954     |   ["\u0b82"-"\u0b83"] 
3955     |   ["\u0bbe"-"\u0bc2"]
3956     |   ["\u0bc6"-"\u0bc8"] 
3957     |   ["\u0bca"-"\u0bcd"] 
3958     |   ["\u0bd7"]
3959     |   ["\u0c01"-"\u0c03"]
3960     |   ["\u0c3e"-"\u0c44"] 
3961     |   ["\u0c46"-"\u0c48"] 
3962     |   ["\u0c4a"-"\u0c4d"] 
3963     |   ["\u0c55"-"\u0c56"]
3964     |   ["\u0c82"-"\u0c83"] 
3965     |   ["\u0cbe"-"\u0cc4"] 
3966     |   ["\u0cc6"-"\u0cc8"] 
3967     |   ["\u0cca"-"\u0ccd"]
3968     |   ["\u0cd5"-"\u0cd6"] 
3969     |   ["\u0d02"-"\u0d03"] 
3970     |   ["\u0d3e"-"\u0d43"] 
3971     |   ["\u0d46"-"\u0d48"]
3972     |   ["\u0d4a"-"\u0d4d"] 
3973     |   ["\u0d57"]
3974     |   ["\u0d82"-"\u0d83"] 
3975     |   ["\u0dca"]
3976     |   ["\u0dcf"-"\u0dd4"] 
3977     |   ["\u0dd6"]
3978     |   ["\u0dd8"-"\u0ddf"] 
3979     |   ["\u0df2"-"\u0df3"]
3980     |   ["\u0e31"]
3981     |   ["\u0e34"-"\u0e3a"] 
3982     |   ["\u0e47"-"\u0e4e"] 
3983     |   ["\u0eb1"]
3984     |   ["\u0eb4"-"\u0eb9"] 
3985     |   ["\u0ebb"-"\u0ebc"] 
3986     |   ["\u0ec8"-"\u0ecd"] 
3987     |   ["\u0f18"-"\u0f19"]
3988     |   ["\u0f35"]
3989     |   ["\u0f37"]
3990     |   ["\u0f39"]
3991     |   ["\u0f3e"-"\u0f3f"]
3992     |   ["\u0f71"-"\u0f84"] 
3993     |   ["\u0f86"-"\u0f87"] 
3994     |   ["\u0f90"-"\u0f97"] 
3995     |   ["\u0f99"-"\u0fbc"]
3996     |   ["\u0fc6"]
3997     |   ["\u102c"-"\u1032"] 
3998     |   ["\u1036"-"\u1039"] 
3999     |   ["\u1056"-"\u1059"]
4000     |   ["\u17b4"-"\u17d3"] 
4001     |   ["\u18a9"]
4002     |   ["\u20d0"-"\u20dc"] 
4003     |   ["\u20e1"]
4004     |   ["\u302a"-"\u302f"] 
4005     |   ["\u3099"-"\u309a"] 
4006     |   ["\ufb1e"]
4007     |   ["\ufe20"-"\ufe23"]
4008     >
4009 |   < UNICODE_DIGIT: 
4010         ["0"-"9"] 
4011     |   ["\u0660"-"\u0669"] 
4012     |   ["\u06f0"-"\u06f9"] 
4013     |   ["\u0966"-"\u096f"]
4014     |   ["\u09e6"-"\u09ef"] 
4015     |   ["\u0a66"-"\u0a6f"] 
4016     |   ["\u0ae6"-"\u0aef"] 
4017     |   ["\u0b66"-"\u0b6f"]
4018     |   ["\u0be7"-"\u0bef"] 
4019     |   ["\u0c66"-"\u0c6f"] 
4020     |   ["\u0ce6"-"\u0cef"] 
4021     |   ["\u0d66"-"\u0d6f"]
4022     |   ["\u0e50"-"\u0e59"] 
4023     |   ["\u0ed0"-"\u0ed9"] 
4024     |   ["\u0f20"-"\u0f29"] 
4025     |   ["\u1040"-"\u1049"]
4026     |   ["\u1369"-"\u1371"] 
4027     |   ["\u17e0"-"\u17e9"] 
4028     |   ["\u1810"-"\u1819"] 
4029     |   ["\uff10"-"\uff19"] 
4030     >
4031 |   < UNICODE_CONNECTOR_PUNCTUATION: 
4032         ["_"] 
4033     |   ["\u203f"-"\u2040"]
4034     |   ["\u30fb"] 
4035     |   ["\ufe33"-"\ufe34"]
4036     |   ["\ufe4d"-"\ufe4f"]
4037     |   ["\uff3f"]
4038     |   ["\uff65"]
4039     >
4040 }
4041 
4042 TOKEN:
4043 {
4044     < UNICODE_ESCAPE_SEQUENCE: "u" <HEX_DIGIT> <HEX_DIGIT> <HEX_DIGIT> <HEX_DIGIT> >
4045 |   < HEX_DIGIT: ["0"-"9"] | ["a"-"f"] | ["A"-"F"] >
4046 }
4047 
4048 /* ECMA-262 5.1 Edition / June 2011 - Section 7.8.5: Regular Expression Literals */
4049 
4050 TOKEN :
4051 {
4052     < REGULAR_EXPRESSION_LITERAL:
4053         "/" ( (~["\n","\r","\\","/","*"]) | <BACKSLASH_SEQUENCE> ) 
4054         ( (~["\n","\r","\\","/"]) | <BACKSLASH_SEQUENCE> )* "/" (<IDENTIFIER_PART>)*
4055     >
4056 |
4057     < #BACKSLASH_SEQUENCE:
4058         "\\" (~["\n","\r"])
4059     >
4060 }
4061 
4062 /* Java Statements For Descripters Only! */
4063 
4064 MORE :
4065 {
4066     "#" : IN_JAVA_STATEMENT
4067 }
4068 
4069 <IN_JAVA_STATEMENT> TOKEN :
4070 {
4071     <JAVA_STATEMENT:
4072         (~["#",";","\n","\r","\u2028","\u2029"])* (";" | "\n" | "\r" | "\r\n" | "\u2028" | "\u2029")?
4073     > : DEFAULT
4074 }
4075 
4076 <IN_JAVA_STATEMENT> MORE :
4077 {
4078     < ~[] >
4079 }
4080