0001
0002 package org.descripter.js.parse;
0003
0004 public class JSParserimplements JSParserTreeConstants, JSParserConstants {
0005 protected JJTJSParserState jjtree = new JJTJSParserState();void jjtreeOpenNodeScope(Node n) {
0006 ((AbstractNode)n).firstToken = getToken(1);
0007 }
0008
0009 void jjtreeCloseNodeScope(Node n) {
0010 ((AbstractNode)n).lastToken = getToken(0);
0011 }
0012
0013
0014 final public void Literal() throws ParseException {
0015
0016 ECMALiteral jjtn000 = new ECMALiteral(this, JJTLITERAL);
0017 boolean jjtc000 = true;
0018 jjtree.openNodeScope(jjtn000);
0019 jjtreeOpenNodeScope(jjtn000);Token t;
0020 try {
0021 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0022 case DECIMAL_LITERAL:
0023 t = jj_consume_token(DECIMAL_LITERAL);
0024 break;
0025 case HEX_INTEGER_LITERAL:
0026 t = jj_consume_token(HEX_INTEGER_LITERAL);
0027 break;
0028 case STRING_LITERAL:
0029 t = jj_consume_token(STRING_LITERAL);
0030 break;
0031 case BOOLEAN_LITERAL:
0032 t = jj_consume_token(BOOLEAN_LITERAL);
0033 break;
0034 case NULL_LITERAL:
0035 t = jj_consume_token(NULL_LITERAL);
0036 break;
0037 case REGULAR_EXPRESSION_LITERAL:
0038 t = jj_consume_token(REGULAR_EXPRESSION_LITERAL);
0039 break;
0040 default:
0041 jj_la1[0] = jj_gen;
0042 jj_consume_token(-1);
0043 throw new ParseException();
0044 }
0045 jjtree.closeNodeScope(jjtn000, true);
0046 jjtc000 = false;
0047 jjtreeCloseNodeScope(jjtn000);
0048 jjtn000.jjtSetValue(t.image);
0049 } finally {
0050 if (jjtc000) {
0051 jjtree.closeNodeScope(jjtn000, true);
0052 jjtreeCloseNodeScope(jjtn000);
0053 }
0054 }
0055 }
0056
0057
0058 final public void PrimaryExpression() throws ParseException {
0059 if (jj_2_1(2147483647)) {
0060 ECMAThisReference jjtn001 = new ECMAThisReference(this, JJTTHISREFERENCE);
0061 boolean jjtc001 = true;
0062 jjtree.openNodeScope(jjtn001);
0063 jjtreeOpenNodeScope(jjtn001);
0064 try {
0065 jj_consume_token(THIS);
0066 } finally {
0067 if (jjtc001) {
0068 jjtree.closeNodeScope(jjtn001, true);
0069 jjtreeCloseNodeScope(jjtn001);
0070 }
0071 }
0072 } else if (jj_2_2(2147483647)) {
0073 ObjectLiteral();
0074 } else if (jj_2_3(2147483647)) {
0075 ECMAGroup jjtn002 = new ECMAGroup(this, JJTGROUP);
0076 boolean jjtc002 = true;
0077 jjtree.openNodeScope(jjtn002);
0078 jjtreeOpenNodeScope(jjtn002);
0079 try {
0080 jj_consume_token(LPAREN);
0081 Expression();
0082 jj_consume_token(RPAREN);
0083 } catch (Throwable jjte002) {
0084 if (jjtc002) {
0085 jjtree.clearNodeScope(jjtn002);
0086 jjtc002 = false;
0087 } else {
0088 jjtree.popNode();
0089 }
0090 if (jjte002 instanceof RuntimeException) {
0091 {if (true) throw (RuntimeException)jjte002;}
0092 }
0093 if (jjte002 instanceof ParseException) {
0094 {if (true) throw (ParseException)jjte002;}
0095 }
0096 {if (true) throw (Error)jjte002;}
0097 } finally {
0098 if (jjtc002) {
0099 jjtree.closeNodeScope(jjtn002, true);
0100 jjtreeCloseNodeScope(jjtn002);
0101 }
0102 }
0103 } else if (jj_2_4(2147483647)) {
0104 Identifier();
0105 } else if (jj_2_5(2147483647)) {
0106 ArrayLiteral();
0107 } else if (jj_2_6(2)) {
0108 Literal();
0109 } else {
0110 jj_consume_token(-1);
0111 throw new ParseException();
0112 }
0113 }
0114
0115
0116 final public void ArrayLiteral() throws ParseException {
0117
0118 ECMAArrayLiteral jjtn000 = new ECMAArrayLiteral(this, JJTARRAYLITERAL);
0119 boolean jjtc000 = true;
0120 jjtree.openNodeScope(jjtn000);
0121 jjtreeOpenNodeScope(jjtn000);
0122 try {
0123 jj_consume_token(LBRACKET);
0124 if (jj_2_7(2)) {
0125 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0126 case COMMA:
0127 Elision();
0128 break;
0129 default:
0130 jj_la1[1] = jj_gen;
0131 ;
0132 }
0133 jj_consume_token(RBRACKET);
0134 } else if (jj_2_8(2147483647)) {
0135 ElementList();
0136 Elision();
0137 jj_consume_token(RBRACKET);
0138 } else {
0139 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0140 case TYPEOF:
0141 case NEW:
0142 case VOID:
0143 case FUNCTION:
0144 case THIS:
0145 case DELETE:
0146 case LBRACE:
0147 case LPAREN:
0148 case LBRACKET:
0149 case RBRACKET:
0150 case COMMA:
0151 case PLUS:
0152 case MINUS:
0153 case INC:
0154 case DEC:
0155 case BNOT:
0156 case NOT:
0157 case NULL_LITERAL:
0158 case BOOLEAN_LITERAL:
0159 case DECIMAL_LITERAL:
0160 case HEX_INTEGER_LITERAL:
0161 case STRING_LITERAL:
0162 case IDENTIFIER_NAME:
0163 case REGULAR_EXPRESSION_LITERAL:
0164 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0165 case TYPEOF:
0166 case NEW:
0167 case VOID:
0168 case FUNCTION:
0169 case THIS:
0170 case DELETE:
0171 case LBRACE:
0172 case LPAREN:
0173 case LBRACKET:
0174 case COMMA:
0175 case PLUS:
0176 case MINUS:
0177 case INC:
0178 case DEC:
0179 case BNOT:
0180 case NOT:
0181 case NULL_LITERAL:
0182 case BOOLEAN_LITERAL:
0183 case DECIMAL_LITERAL:
0184 case HEX_INTEGER_LITERAL:
0185 case STRING_LITERAL:
0186 case IDENTIFIER_NAME:
0187 case REGULAR_EXPRESSION_LITERAL:
0188 ElementList();
0189 break;
0190 default:
0191 jj_la1[2] = jj_gen;
0192 ;
0193 }
0194 jj_consume_token(RBRACKET);
0195 break;
0196 default:
0197 jj_la1[3] = jj_gen;
0198 jj_consume_token(-1);
0199 throw new ParseException();
0200 }
0201 }
0202 } catch (Throwable jjte000) {
0203 if (jjtc000) {
0204 jjtree.clearNodeScope(jjtn000);
0205 jjtc000 = false;
0206 } else {
0207 jjtree.popNode();
0208 }
0209 if (jjte000 instanceof RuntimeException) {
0210 {if (true) throw (RuntimeException)jjte000;}
0211 }
0212 if (jjte000 instanceof ParseException) {
0213 {if (true) throw (ParseException)jjte000;}
0214 }
0215 {if (true) throw (Error)jjte000;}
0216 } finally {
0217 if (jjtc000) {
0218 jjtree.closeNodeScope(jjtn000, true);
0219 jjtreeCloseNodeScope(jjtn000);
0220 }
0221 }
0222 }
0223
0224 final public void ElementList() throws ParseException {
0225 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0226 case COMMA:
0227 Elision();
0228 break;
0229 default:
0230 jj_la1[4] = jj_gen;
0231 ;
0232 }
0233 AssignmentExpression();
0234 label_1:
0235 while (true) {
0236 if (jj_2_9(2147483647)) {
0237 ;
0238 } else {
0239 break label_1;
0240 }
0241 Elision();
0242 AssignmentExpression();
0243 }
0244 }
0245
0246 final public void Elision() throws ParseException {
0247 label_2:
0248 while (true) {
0249 jj_consume_token(COMMA);
0250 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0251 case COMMA:
0252 ;
0253 break;
0254 default:
0255 jj_la1[5] = jj_gen;
0256 break label_2;
0257 }
0258 }
0259 }
0260
0261
0262 final public void ObjectLiteral() throws ParseException {
0263
0264 ECMAObjectLiteral jjtn000 = new ECMAObjectLiteral(this, JJTOBJECTLITERAL);
0265 boolean jjtc000 = true;
0266 jjtree.openNodeScope(jjtn000);
0267 jjtreeOpenNodeScope(jjtn000);
0268 try {
0269 jj_consume_token(LBRACE);
0270 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0271 case DECIMAL_LITERAL:
0272 case STRING_LITERAL:
0273 case IDENTIFIER_NAME:
0274 PropertyNameAndValueList();
0275 break;
0276 default:
0277 jj_la1[6] = jj_gen;
0278 ;
0279 }
0280 jj_consume_token(RBRACE);
0281 } catch (Throwable jjte000) {
0282 if (jjtc000) {
0283 jjtree.clearNodeScope(jjtn000);
0284 jjtc000 = false;
0285 } else {
0286 jjtree.popNode();
0287 }
0288 if (jjte000 instanceof RuntimeException) {
0289 {if (true) throw (RuntimeException)jjte000;}
0290 }
0291 if (jjte000 instanceof ParseException) {
0292 {if (true) throw (ParseException)jjte000;}
0293 }
0294 {if (true) throw (Error)jjte000;}
0295 } finally {
0296 if (jjtc000) {
0297 jjtree.closeNodeScope(jjtn000, true);
0298 jjtreeCloseNodeScope(jjtn000);
0299 }
0300 }
0301 }
0302
0303 final public void PropertyNameAndValueList() throws ParseException {
0304 PropertyAssignment();
0305 label_3:
0306 while (true) {
0307 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0308 case COMMA:
0309 ;
0310 break;
0311 default:
0312 jj_la1[7] = jj_gen;
0313 break label_3;
0314 }
0315 if (jj_2_10(2147483647)) {
0316 jj_consume_token(COMMA);
0317 PropertyAssignment();
0318 } else {
0319 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0320 case COMMA:
0321 jj_consume_token(COMMA);
0322 break;
0323 default:
0324 jj_la1[8] = jj_gen;
0325 jj_consume_token(-1);
0326 throw new ParseException();
0327 }
0328 }
0329 }
0330 }
0331
0332 final public void PropertyAssignment() throws ParseException {
0333
0334 ECMAPropertyAssignment jjtn000 = new ECMAPropertyAssignment(this, JJTPROPERTYASSIGNMENT);
0335 boolean jjtc000 = true;
0336 jjtree.openNodeScope(jjtn000);
0337 jjtreeOpenNodeScope(jjtn000);
0338 try {
0339 PropertyName();
0340 jj_consume_token(COLON);
0341 AssignmentExpression();
0342 } catch (Throwable jjte000) {
0343 if (jjtc000) {
0344 jjtree.clearNodeScope(jjtn000);
0345 jjtc000 = false;
0346 } else {
0347 jjtree.popNode();
0348 }
0349 if (jjte000 instanceof RuntimeException) {
0350 {if (true) throw (RuntimeException)jjte000;}
0351 }
0352 if (jjte000 instanceof ParseException) {
0353 {if (true) throw (ParseException)jjte000;}
0354 }
0355 {if (true) throw (Error)jjte000;}
0356 } finally {
0357 if (jjtc000) {
0358 jjtree.closeNodeScope(jjtn000, true);
0359 jjtreeCloseNodeScope(jjtn000);
0360 }
0361 }
0362 }
0363
0364 final public void PropertyName() throws ParseException {
0365 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0366 case IDENTIFIER_NAME:
0367 Identifier();
0368 break;
0369 case STRING_LITERAL:
0370 ECMALiteral jjtn001 = new ECMALiteral(this, JJTLITERAL);
0371 boolean jjtc001 = true;
0372 jjtree.openNodeScope(jjtn001);
0373 jjtreeOpenNodeScope(jjtn001);
0374 try {
0375 jj_consume_token(STRING_LITERAL);
0376 } finally {
0377 if (jjtc001) {
0378 jjtree.closeNodeScope(jjtn001, true);
0379 jjtreeCloseNodeScope(jjtn001);
0380 }
0381 }
0382 break;
0383 case DECIMAL_LITERAL:
0384 ECMALiteral jjtn002 = new ECMALiteral(this, JJTLITERAL);
0385 boolean jjtc002 = true;
0386 jjtree.openNodeScope(jjtn002);
0387 jjtreeOpenNodeScope(jjtn002);
0388 try {
0389 jj_consume_token(DECIMAL_LITERAL);
0390 } finally {
0391 if (jjtc002) {
0392 jjtree.closeNodeScope(jjtn002, true);
0393 jjtreeCloseNodeScope(jjtn002);
0394 }
0395 }
0396 break;
0397 default:
0398 jj_la1[9] = jj_gen;
0399 jj_consume_token(-1);
0400 throw new ParseException();
0401 }
0402 }
0403
0404
0405 final public void MemberExpression() throws ParseException {
0406 ECMAAccess jjtn002 = new ECMAAccess(this, JJTACCESS);
0407 boolean jjtc002 = true;
0408 jjtree.openNodeScope(jjtn002);
0409 jjtreeOpenNodeScope(jjtn002);
0410 try {
0411 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0412 case THIS:
0413 case LBRACE:
0414 case LPAREN:
0415 case LBRACKET:
0416 case NULL_LITERAL:
0417 case BOOLEAN_LITERAL:
0418 case DECIMAL_LITERAL:
0419 case HEX_INTEGER_LITERAL:
0420 case STRING_LITERAL:
0421 case IDENTIFIER_NAME:
0422 case REGULAR_EXPRESSION_LITERAL:
0423 PrimaryExpression();
0424 break;
0425 case FUNCTION:
0426 FunctionExpression();
0427 break;
0428 case NEW:
0429 ECMANewOperation jjtn001 = new ECMANewOperation(this, JJTNEWOPERATION);
0430 boolean jjtc001 = true;
0431 jjtree.openNodeScope(jjtn001);
0432 jjtreeOpenNodeScope(jjtn001);
0433 try {
0434 jj_consume_token(NEW);
0435 MemberExpression();
0436 Arguments();
0437 } catch (Throwable jjte001) {
0438 if (jjtc001) {
0439 jjtree.clearNodeScope(jjtn001);
0440 jjtc001 = false;
0441 } else {
0442 jjtree.popNode();
0443 }
0444 if (jjte001 instanceof RuntimeException) {
0445 {if (true) throw (RuntimeException)jjte001;}
0446 }
0447 if (jjte001 instanceof ParseException) {
0448 {if (true) throw (ParseException)jjte001;}
0449 }
0450 {if (true) throw (Error)jjte001;}
0451 } finally {
0452 if (jjtc001) {
0453 jjtree.closeNodeScope(jjtn001, true);
0454 jjtreeCloseNodeScope(jjtn001);
0455 }
0456 }
0457 break;
0458 default:
0459 jj_la1[10] = jj_gen;
0460 jj_consume_token(-1);
0461 throw new ParseException();
0462 }
0463 label_4:
0464 while (true) {
0465 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0466 case LBRACKET:
0467 case DOT:
0468 ;
0469 break;
0470 default:
0471 jj_la1[11] = jj_gen;
0472 break label_4;
0473 }
0474 PropertyAccessor();
0475 }
0476 } catch (Throwable jjte002) {
0477 if (jjtc002) {
0478 jjtree.clearNodeScope(jjtn002);
0479 jjtc002 = false;
0480 } else {
0481 jjtree.popNode();
0482 }
0483 if (jjte002 instanceof RuntimeException) {
0484 {if (true) throw (RuntimeException)jjte002;}
0485 }
0486 if (jjte002 instanceof ParseException) {
0487 {if (true) throw (ParseException)jjte002;}
0488 }
0489 {if (true) throw (Error)jjte002;}
0490 } finally {
0491 if (jjtc002) {
0492 jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() > 1);
0493 jjtreeCloseNodeScope(jjtn002);
0494 }
0495 }
0496 }
0497
0498 final public void NewExpression() throws ParseException {
0499 if (jj_2_11(2147483647)) {
0500 MemberExpression();
0501 } else {
0502 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0503 case NEW:
0504 ECMAAllocation jjtn001 = new ECMAAllocation(this, JJTALLOCATION);
0505 boolean jjtc001 = true;
0506 jjtree.openNodeScope(jjtn001);
0507 jjtreeOpenNodeScope(jjtn001);
0508 try {
0509 jj_consume_token(NEW);
0510 NewExpression();
0511 } catch (Throwable jjte001) {
0512 if (jjtc001) {
0513 jjtree.clearNodeScope(jjtn001);
0514 jjtc001 = false;
0515 } else {
0516 jjtree.popNode();
0517 }
0518 if (jjte001 instanceof RuntimeException) {
0519 {if (true) throw (RuntimeException)jjte001;}
0520 }
0521 if (jjte001 instanceof ParseException) {
0522 {if (true) throw (ParseException)jjte001;}
0523 }
0524 {if (true) throw (Error)jjte001;}
0525 } finally {
0526 if (jjtc001) {
0527 jjtree.closeNodeScope(jjtn001, true);
0528 jjtreeCloseNodeScope(jjtn001);
0529 }
0530 }
0531 break;
0532 default:
0533 jj_la1[12] = jj_gen;
0534 jj_consume_token(-1);
0535 throw new ParseException();
0536 }
0537 }
0538 }
0539
0540 final public void PropertyAccessor() throws ParseException {
0541 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0542 case LBRACKET:
0543 ECMAArrayAccessor jjtn001 = new ECMAArrayAccessor(this, JJTARRAYACCESSOR);
0544 boolean jjtc001 = true;
0545 jjtree.openNodeScope(jjtn001);
0546 jjtreeOpenNodeScope(jjtn001);
0547 try {
0548 jj_consume_token(LBRACKET);
0549 Expression();
0550 jj_consume_token(RBRACKET);
0551 } catch (Throwable jjte001) {
0552 if (jjtc001) {
0553 jjtree.clearNodeScope(jjtn001);
0554 jjtc001 = false;
0555 } else {
0556 jjtree.popNode();
0557 }
0558 if (jjte001 instanceof RuntimeException) {
0559 {if (true) throw (RuntimeException)jjte001;}
0560 }
0561 if (jjte001 instanceof ParseException) {
0562 {if (true) throw (ParseException)jjte001;}
0563 }
0564 {if (true) throw (Error)jjte001;}
0565 } finally {
0566 if (jjtc001) {
0567 jjtree.closeNodeScope(jjtn001, true);
0568 jjtreeCloseNodeScope(jjtn001);
0569 }
0570 }
0571 break;
0572 case DOT:
0573 ECMAMemberAccessor jjtn002 = new ECMAMemberAccessor(this, JJTMEMBERACCESSOR);
0574 boolean jjtc002 = true;
0575 jjtree.openNodeScope(jjtn002);
0576 jjtreeOpenNodeScope(jjtn002);
0577 try {
0578 jj_consume_token(DOT);
0579 Identifier();
0580 } catch (Throwable jjte002) {
0581 if (jjtc002) {
0582 jjtree.clearNodeScope(jjtn002);
0583 jjtc002 = false;
0584 } else {
0585 jjtree.popNode();
0586 }
0587 if (jjte002 instanceof RuntimeException) {
0588 {if (true) throw (RuntimeException)jjte002;}
0589 }
0590 if (jjte002 instanceof ParseException) {
0591 {if (true) throw (ParseException)jjte002;}
0592 }
0593 {if (true) throw (Error)jjte002;}
0594 } finally {
0595 if (jjtc002) {
0596 jjtree.closeNodeScope(jjtn002, true);
0597 jjtreeCloseNodeScope(jjtn002);
0598 }
0599 }
0600 break;
0601 default:
0602 jj_la1[13] = jj_gen;
0603 jj_consume_token(-1);
0604 throw new ParseException();
0605 }
0606 }
0607
0608 final public void CallExpression() throws ParseException {
0609
0610 ECMAAccess jjtn000 = new ECMAAccess(this, JJTACCESS);
0611 boolean jjtc000 = true;
0612 jjtree.openNodeScope(jjtn000);
0613 jjtreeOpenNodeScope(jjtn000);
0614 try {
0615 MemberExpression();
0616 Arguments();
0617 label_5:
0618 while (true) {
0619 if (jj_2_12(2)) {
0620 ;
0621 } else {
0622 break label_5;
0623 }
0624 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0625 case LPAREN:
0626 Arguments();
0627 break;
0628 case LBRACKET:
0629 case DOT:
0630 PropertyAccessor();
0631 break;
0632 default:
0633 jj_la1[14] = jj_gen;
0634 jj_consume_token(-1);
0635 throw new ParseException();
0636 }
0637 }
0638 } catch (Throwable jjte000) {
0639 if (jjtc000) {
0640 jjtree.clearNodeScope(jjtn000);
0641 jjtc000 = false;
0642 } else {
0643 jjtree.popNode();
0644 }
0645 if (jjte000 instanceof RuntimeException) {
0646 {if (true) throw (RuntimeException)jjte000;}
0647 }
0648 if (jjte000 instanceof ParseException) {
0649 {if (true) throw (ParseException)jjte000;}
0650 }
0651 {if (true) throw (Error)jjte000;}
0652 } finally {
0653 if (jjtc000) {
0654 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0655 jjtreeCloseNodeScope(jjtn000);
0656 }
0657 }
0658 }
0659
0660 final public void Arguments() throws ParseException {
0661
0662 ECMAArguments jjtn000 = new ECMAArguments(this, JJTARGUMENTS);
0663 boolean jjtc000 = true;
0664 jjtree.openNodeScope(jjtn000);
0665 jjtreeOpenNodeScope(jjtn000);
0666 try {
0667 jj_consume_token(LPAREN);
0668 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0669 case TYPEOF:
0670 case NEW:
0671 case VOID:
0672 case FUNCTION:
0673 case THIS:
0674 case DELETE:
0675 case LBRACE:
0676 case LPAREN:
0677 case LBRACKET:
0678 case PLUS:
0679 case MINUS:
0680 case INC:
0681 case DEC:
0682 case BNOT:
0683 case NOT:
0684 case NULL_LITERAL:
0685 case BOOLEAN_LITERAL:
0686 case DECIMAL_LITERAL:
0687 case HEX_INTEGER_LITERAL:
0688 case STRING_LITERAL:
0689 case IDENTIFIER_NAME:
0690 case REGULAR_EXPRESSION_LITERAL:
0691 ArgumentList();
0692 break;
0693 default:
0694 jj_la1[15] = jj_gen;
0695 ;
0696 }
0697 jj_consume_token(RPAREN);
0698 } catch (Throwable jjte000) {
0699 if (jjtc000) {
0700 jjtree.clearNodeScope(jjtn000);
0701 jjtc000 = false;
0702 } else {
0703 jjtree.popNode();
0704 }
0705 if (jjte000 instanceof RuntimeException) {
0706 {if (true) throw (RuntimeException)jjte000;}
0707 }
0708 if (jjte000 instanceof ParseException) {
0709 {if (true) throw (ParseException)jjte000;}
0710 }
0711 {if (true) throw (Error)jjte000;}
0712 } finally {
0713 if (jjtc000) {
0714 jjtree.closeNodeScope(jjtn000, true);
0715 jjtreeCloseNodeScope(jjtn000);
0716 }
0717 }
0718 }
0719
0720 final public void ArgumentList() throws ParseException {
0721 AssignmentExpression();
0722 label_6:
0723 while (true) {
0724 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0725 case COMMA:
0726 ;
0727 break;
0728 default:
0729 jj_la1[16] = jj_gen;
0730 break label_6;
0731 }
0732 jj_consume_token(COMMA);
0733 AssignmentExpression();
0734 }
0735 }
0736
0737 final public void LeftHandSideExpression() throws ParseException {
0738 if (jj_2_13(2147483647)) {
0739 CallExpression();
0740 } else {
0741 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0742 case NEW:
0743 case FUNCTION:
0744 case THIS:
0745 case LBRACE:
0746 case LPAREN:
0747 case LBRACKET:
0748 case NULL_LITERAL:
0749 case BOOLEAN_LITERAL:
0750 case DECIMAL_LITERAL:
0751 case HEX_INTEGER_LITERAL:
0752 case STRING_LITERAL:
0753 case IDENTIFIER_NAME:
0754 case REGULAR_EXPRESSION_LITERAL:
0755 NewExpression();
0756 break;
0757 default:
0758 jj_la1[17] = jj_gen;
0759 jj_consume_token(-1);
0760 throw new ParseException();
0761 }
0762 }
0763 }
0764
0765
0766 final public void PostfixExpression() throws ParseException {
0767
0768 ECMAPostfixExpression jjtn000 = new ECMAPostfixExpression(this, JJTPOSTFIXEXPRESSION);
0769 boolean jjtc000 = true;
0770 jjtree.openNodeScope(jjtn000);
0771 jjtreeOpenNodeScope(jjtn000);
0772 try {
0773 LeftHandSideExpression();
0774 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0775 case INC:
0776 case DEC:
0777 ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0778 boolean jjtc001 = true;
0779 jjtree.openNodeScope(jjtn001);
0780 jjtreeOpenNodeScope(jjtn001);
0781 try {
0782 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0783 case INC:
0784 jj_consume_token(INC);
0785 break;
0786 case DEC:
0787 jj_consume_token(DEC);
0788 break;
0789 default:
0790 jj_la1[18] = jj_gen;
0791 jj_consume_token(-1);
0792 throw new ParseException();
0793 }
0794 } finally {
0795 if (jjtc001) {
0796 jjtree.closeNodeScope(jjtn001, true);
0797 jjtreeCloseNodeScope(jjtn001);
0798 }
0799 }
0800 break;
0801 default:
0802 jj_la1[19] = jj_gen;
0803 ;
0804 }
0805 } catch (Throwable jjte000) {
0806 if (jjtc000) {
0807 jjtree.clearNodeScope(jjtn000);
0808 jjtc000 = false;
0809 } else {
0810 jjtree.popNode();
0811 }
0812 if (jjte000 instanceof RuntimeException) {
0813 {if (true) throw (RuntimeException)jjte000;}
0814 }
0815 if (jjte000 instanceof ParseException) {
0816 {if (true) throw (ParseException)jjte000;}
0817 }
0818 {if (true) throw (Error)jjte000;}
0819 } finally {
0820 if (jjtc000) {
0821 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0822 jjtreeCloseNodeScope(jjtn000);
0823 }
0824 }
0825 }
0826
0827
0828 final public void UnaryExpression() throws ParseException {
0829
0830 ECMAUnaryExpression jjtn000 = new ECMAUnaryExpression(this, JJTUNARYEXPRESSION);
0831 boolean jjtc000 = true;
0832 jjtree.openNodeScope(jjtn000);
0833 jjtreeOpenNodeScope(jjtn000);
0834 try {
0835 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0836 case NEW:
0837 case FUNCTION:
0838 case THIS:
0839 case LBRACE:
0840 case LPAREN:
0841 case LBRACKET:
0842 case NULL_LITERAL:
0843 case BOOLEAN_LITERAL:
0844 case DECIMAL_LITERAL:
0845 case HEX_INTEGER_LITERAL:
0846 case STRING_LITERAL:
0847 case IDENTIFIER_NAME:
0848 case REGULAR_EXPRESSION_LITERAL:
0849 PostfixExpression();
0850 break;
0851 case TYPEOF:
0852 case VOID:
0853 case DELETE:
0854 case PLUS:
0855 case MINUS:
0856 case INC:
0857 case DEC:
0858 case BNOT:
0859 case NOT:
0860 ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0861 boolean jjtc001 = true;
0862 jjtree.openNodeScope(jjtn001);
0863 jjtreeOpenNodeScope(jjtn001);
0864 try {
0865 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0866 case DELETE:
0867 jj_consume_token(DELETE);
0868 break;
0869 case VOID:
0870 jj_consume_token(VOID);
0871 break;
0872 case TYPEOF:
0873 jj_consume_token(TYPEOF);
0874 break;
0875 case INC:
0876 jj_consume_token(INC);
0877 break;
0878 case DEC:
0879 jj_consume_token(DEC);
0880 break;
0881 case PLUS:
0882 jj_consume_token(PLUS);
0883 break;
0884 case MINUS:
0885 jj_consume_token(MINUS);
0886 break;
0887 case NOT:
0888 jj_consume_token(NOT);
0889 break;
0890 case BNOT:
0891 jj_consume_token(BNOT);
0892 break;
0893 default:
0894 jj_la1[20] = jj_gen;
0895 jj_consume_token(-1);
0896 throw new ParseException();
0897 }
0898 } finally {
0899 if (jjtc001) {
0900 jjtree.closeNodeScope(jjtn001, true);
0901 jjtreeCloseNodeScope(jjtn001);
0902 }
0903 }
0904 UnaryExpression();
0905 break;
0906 default:
0907 jj_la1[21] = jj_gen;
0908 jj_consume_token(-1);
0909 throw new ParseException();
0910 }
0911 } catch (Throwable jjte000) {
0912 if (jjtc000) {
0913 jjtree.clearNodeScope(jjtn000);
0914 jjtc000 = false;
0915 } else {
0916 jjtree.popNode();
0917 }
0918 if (jjte000 instanceof RuntimeException) {
0919 {if (true) throw (RuntimeException)jjte000;}
0920 }
0921 if (jjte000 instanceof ParseException) {
0922 {if (true) throw (ParseException)jjte000;}
0923 }
0924 {if (true) throw (Error)jjte000;}
0925 } finally {
0926 if (jjtc000) {
0927 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0928 jjtreeCloseNodeScope(jjtn000);
0929 }
0930 }
0931 }
0932
0933
0934 final public void MultiplicativeExpression() throws ParseException {
0935
0936 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
0937 boolean jjtc000 = true;
0938 jjtree.openNodeScope(jjtn000);
0939 jjtreeOpenNodeScope(jjtn000);
0940 try {
0941 UnaryExpression();
0942 label_7:
0943 while (true) {
0944 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0945 case MUL:
0946 case MOD:
0947 case DIV:
0948 ;
0949 break;
0950 default:
0951 jj_la1[22] = jj_gen;
0952 break label_7;
0953 }
0954 ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0955 boolean jjtc001 = true;
0956 jjtree.openNodeScope(jjtn001);
0957 jjtreeOpenNodeScope(jjtn001);
0958 try {
0959 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0960 case MUL:
0961 jj_consume_token(MUL);
0962 break;
0963 case DIV:
0964 jj_consume_token(DIV);
0965 break;
0966 case MOD:
0967 jj_consume_token(MOD);
0968 break;
0969 default:
0970 jj_la1[23] = jj_gen;
0971 jj_consume_token(-1);
0972 throw new ParseException();
0973 }
0974 } finally {
0975 if (jjtc001) {
0976 jjtree.closeNodeScope(jjtn001, true);
0977 jjtreeCloseNodeScope(jjtn001);
0978 }
0979 }
0980 UnaryExpression();
0981 }
0982 } catch (Throwable jjte000) {
0983 if (jjtc000) {
0984 jjtree.clearNodeScope(jjtn000);
0985 jjtc000 = false;
0986 } else {
0987 jjtree.popNode();
0988 }
0989 if (jjte000 instanceof RuntimeException) {
0990 {if (true) throw (RuntimeException)jjte000;}
0991 }
0992 if (jjte000 instanceof ParseException) {
0993 {if (true) throw (ParseException)jjte000;}
0994 }
0995 {if (true) throw (Error)jjte000;}
0996 } finally {
0997 if (jjtc000) {
0998 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0999 jjtreeCloseNodeScope(jjtn000);
1000 }
1001 }
1002 }
1003
1004
1005 final public void AdditiveExpression() throws ParseException {
1006
1007 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1008 boolean jjtc000 = true;
1009 jjtree.openNodeScope(jjtn000);
1010 jjtreeOpenNodeScope(jjtn000);
1011 try {
1012 MultiplicativeExpression();
1013 label_8:
1014 while (true) {
1015 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1016 case PLUS:
1017 case MINUS:
1018 ;
1019 break;
1020 default:
1021 jj_la1[24] = jj_gen;
1022 break label_8;
1023 }
1024 ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1025 boolean jjtc001 = true;
1026 jjtree.openNodeScope(jjtn001);
1027 jjtreeOpenNodeScope(jjtn001);
1028 try {
1029 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1030 case PLUS:
1031 jj_consume_token(PLUS);
1032 break;
1033 case MINUS:
1034 jj_consume_token(MINUS);
1035 break;
1036 default:
1037 jj_la1[25] = jj_gen;
1038 jj_consume_token(-1);
1039 throw new ParseException();
1040 }
1041 } finally {
1042 if (jjtc001) {
1043 jjtree.closeNodeScope(jjtn001, true);
1044 jjtreeCloseNodeScope(jjtn001);
1045 }
1046 }
1047 MultiplicativeExpression();
1048 }
1049 } catch (Throwable jjte000) {
1050 if (jjtc000) {
1051 jjtree.clearNodeScope(jjtn000);
1052 jjtc000 = false;
1053 } else {
1054 jjtree.popNode();
1055 }
1056 if (jjte000 instanceof RuntimeException) {
1057 {if (true) throw (RuntimeException)jjte000;}
1058 }
1059 if (jjte000 instanceof ParseException) {
1060 {if (true) throw (ParseException)jjte000;}
1061 }
1062 {if (true) throw (Error)jjte000;}
1063 } finally {
1064 if (jjtc000) {
1065 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1066 jjtreeCloseNodeScope(jjtn000);
1067 }
1068 }
1069 }
1070
1071
1072 final public void ShiftExpression() throws ParseException {
1073
1074 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1075 boolean jjtc000 = true;
1076 jjtree.openNodeScope(jjtn000);
1077 jjtreeOpenNodeScope(jjtn000);
1078 try {
1079 AdditiveExpression();
1080 label_9:
1081 while (true) {
1082 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1083 case SHL:
1084 case SHR:
1085 case SHRU:
1086 ;
1087 break;
1088 default:
1089 jj_la1[26] = jj_gen;
1090 break label_9;
1091 }
1092 ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1093 boolean jjtc001 = true;
1094 jjtree.openNodeScope(jjtn001);
1095 jjtreeOpenNodeScope(jjtn001);
1096 try {
1097 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1098 case SHL:
1099 jj_consume_token(SHL);
1100 break;
1101 case SHR:
1102 jj_consume_token(SHR);
1103 break;
1104 case SHRU:
1105 jj_consume_token(SHRU);
1106 break;
1107 default:
1108 jj_la1[27] = jj_gen;
1109 jj_consume_token(-1);
1110 throw new ParseException();
1111 }
1112 } finally {
1113 if (jjtc001) {
1114 jjtree.closeNodeScope(jjtn001, true);
1115 jjtreeCloseNodeScope(jjtn001);
1116 }
1117 }
1118 AdditiveExpression();
1119 }
1120 } catch (Throwable jjte000) {
1121 if (jjtc000) {
1122 jjtree.clearNodeScope(jjtn000);
1123 jjtc000 = false;
1124 } else {
1125 jjtree.popNode();
1126 }
1127 if (jjte000 instanceof RuntimeException) {
1128 {if (true) throw (RuntimeException)jjte000;}
1129 }
1130 if (jjte000 instanceof ParseException) {
1131 {if (true) throw (ParseException)jjte000;}
1132 }
1133 {if (true) throw (Error)jjte000;}
1134 } finally {
1135 if (jjtc000) {
1136 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1137 jjtreeCloseNodeScope(jjtn000);
1138 }
1139 }
1140 }
1141
1142
1143 final public void RelationalExpression() throws ParseException {
1144
1145 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1146 boolean jjtc000 = true;
1147 jjtree.openNodeScope(jjtn000);
1148 jjtreeOpenNodeScope(jjtn000);
1149 try {
1150 ShiftExpression();
1151 label_10:
1152 while (true) {
1153 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1154 case INSTANCEOF:
1155 case IN:
1156 case LT:
1157 case GT:
1158 case LTE:
1159 case GTE:
1160 ;
1161 break;
1162 default:
1163 jj_la1[28] = jj_gen;
1164 break label_10;
1165 }
1166 ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1167 boolean jjtc001 = true;
1168 jjtree.openNodeScope(jjtn001);
1169 jjtreeOpenNodeScope(jjtn001);
1170 try {
1171 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1172 case INSTANCEOF:
1173 case LT:
1174 case GT:
1175 case LTE:
1176 case GTE:
1177 RelationalOperatorNoIn();
1178 break;
1179 case IN:
1180 jj_consume_token(IN);
1181 break;
1182 default:
1183 jj_la1[29] = jj_gen;
1184 jj_consume_token(-1);
1185 throw new ParseException();
1186 }
1187 } catch (Throwable jjte001) {
1188 if (jjtc001) {
1189 jjtree.clearNodeScope(jjtn001);
1190 jjtc001 = false;
1191 } else {
1192 jjtree.popNode();
1193 }
1194 if (jjte001 instanceof RuntimeException) {
1195 {if (true) throw (RuntimeException)jjte001;}
1196 }
1197 if (jjte001 instanceof ParseException) {
1198 {if (true) throw (ParseException)jjte001;}
1199 }
1200 {if (true) throw (Error)jjte001;}
1201 } finally {
1202 if (jjtc001) {
1203 jjtree.closeNodeScope(jjtn001, true);
1204 jjtreeCloseNodeScope(jjtn001);
1205 }
1206 }
1207 ShiftExpression();
1208 }
1209 } catch (Throwable jjte000) {
1210 if (jjtc000) {
1211 jjtree.clearNodeScope(jjtn000);
1212 jjtc000 = false;
1213 } else {
1214 jjtree.popNode();
1215 }
1216 if (jjte000 instanceof RuntimeException) {
1217 {if (true) throw (RuntimeException)jjte000;}
1218 }
1219 if (jjte000 instanceof ParseException) {
1220 {if (true) throw (ParseException)jjte000;}
1221 }
1222 {if (true) throw (Error)jjte000;}
1223 } finally {
1224 if (jjtc000) {
1225 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1226 jjtreeCloseNodeScope(jjtn000);
1227 }
1228 }
1229 }
1230
1231 final public void RelationalExpressionNoIn() throws ParseException {
1232
1233 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1234 boolean jjtc000 = true;
1235 jjtree.openNodeScope(jjtn000);
1236 jjtreeOpenNodeScope(jjtn000);
1237 try {
1238 ShiftExpression();
1239 label_11:
1240 while (true) {
1241 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1242 case INSTANCEOF:
1243 case LT:
1244 case GT:
1245 case LTE:
1246 case GTE:
1247 ;
1248 break;
1249 default:
1250 jj_la1[30] = jj_gen;
1251 break label_11;
1252 }
1253 ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1254 boolean jjtc001 = true;
1255 jjtree.openNodeScope(jjtn001);
1256 jjtreeOpenNodeScope(jjtn001);
1257 try {
1258 RelationalOperatorNoIn();
1259 } catch (Throwable jjte001) {
1260 if (jjtc001) {
1261 jjtree.clearNodeScope(jjtn001);
1262 jjtc001 = false;
1263 } else {
1264 jjtree.popNode();
1265 }
1266 if (jjte001 instanceof RuntimeException) {
1267 {if (true) throw (RuntimeException)jjte001;}
1268 }
1269 if (jjte001 instanceof ParseException) {
1270 {if (true) throw (ParseException)jjte001;}
1271 }
1272 {if (true) throw (Error)jjte001;}
1273 } finally {
1274 if (jjtc001) {
1275 jjtree.closeNodeScope(jjtn001, true);
1276 jjtreeCloseNodeScope(jjtn001);
1277 }
1278 }
1279 ShiftExpression();
1280 }
1281 } catch (Throwable jjte000) {
1282 if (jjtc000) {
1283 jjtree.clearNodeScope(jjtn000);
1284 jjtc000 = false;
1285 } else {
1286 jjtree.popNode();
1287 }
1288 if (jjte000 instanceof RuntimeException) {
1289 {if (true) throw (RuntimeException)jjte000;}
1290 }
1291 if (jjte000 instanceof ParseException) {
1292 {if (true) throw (ParseException)jjte000;}
1293 }
1294 {if (true) throw (Error)jjte000;}
1295 } finally {
1296 if (jjtc000) {
1297 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1298 jjtreeCloseNodeScope(jjtn000);
1299 }
1300 }
1301 }
1302
1303 final public void RelationalOperatorNoIn() throws ParseException {
1304 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1305 case LT:
1306 jj_consume_token(LT);
1307 break;
1308 case GT:
1309 jj_consume_token(GT);
1310 break;
1311 case LTE:
1312 jj_consume_token(LTE);
1313 break;
1314 case GTE:
1315 jj_consume_token(GTE);
1316 break;
1317 case INSTANCEOF:
1318 jj_consume_token(INSTANCEOF);
1319 break;
1320 default:
1321 jj_la1[31] = jj_gen;
1322 jj_consume_token(-1);
1323 throw new ParseException();
1324 }
1325 }
1326
1327
1328 final public void EqualityExpression() throws ParseException {
1329
1330 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1331 boolean jjtc000 = true;
1332 jjtree.openNodeScope(jjtn000);
1333 jjtreeOpenNodeScope(jjtn000);
1334 try {
1335 RelationalExpression();
1336 label_12:
1337 while (true) {
1338 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1339 case EQ:
1340 case NE:
1341 case EQS:
1342 case NEQS:
1343 ;
1344 break;
1345 default:
1346 jj_la1[32] = jj_gen;
1347 break label_12;
1348 }
1349 EqualityOperator();
1350 RelationalExpression();
1351 }
1352 } catch (Throwable jjte000) {
1353 if (jjtc000) {
1354 jjtree.clearNodeScope(jjtn000);
1355 jjtc000 = false;
1356 } else {
1357 jjtree.popNode();
1358 }
1359 if (jjte000 instanceof RuntimeException) {
1360 {if (true) throw (RuntimeException)jjte000;}
1361 }
1362 if (jjte000 instanceof ParseException) {
1363 {if (true) throw (ParseException)jjte000;}
1364 }
1365 {if (true) throw (Error)jjte000;}
1366 } finally {
1367 if (jjtc000) {
1368 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1369 jjtreeCloseNodeScope(jjtn000);
1370 }
1371 }
1372 }
1373
1374 final public void EqualityExpressionNoIn() throws ParseException {
1375
1376 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1377 boolean jjtc000 = true;
1378 jjtree.openNodeScope(jjtn000);
1379 jjtreeOpenNodeScope(jjtn000);
1380 try {
1381 RelationalExpressionNoIn();
1382 label_13:
1383 while (true) {
1384 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1385 case EQ:
1386 case NE:
1387 case EQS:
1388 case NEQS:
1389 ;
1390 break;
1391 default:
1392 jj_la1[33] = jj_gen;
1393 break label_13;
1394 }
1395 EqualityOperator();
1396 RelationalExpressionNoIn();
1397 }
1398 } catch (Throwable jjte000) {
1399 if (jjtc000) {
1400 jjtree.clearNodeScope(jjtn000);
1401 jjtc000 = false;
1402 } else {
1403 jjtree.popNode();
1404 }
1405 if (jjte000 instanceof RuntimeException) {
1406 {if (true) throw (RuntimeException)jjte000;}
1407 }
1408 if (jjte000 instanceof ParseException) {
1409 {if (true) throw (ParseException)jjte000;}
1410 }
1411 {if (true) throw (Error)jjte000;}
1412 } finally {
1413 if (jjtc000) {
1414 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1415 jjtreeCloseNodeScope(jjtn000);
1416 }
1417 }
1418 }
1419
1420 final public void EqualityOperator() throws ParseException {
1421
1422 ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1423 boolean jjtc000 = true;
1424 jjtree.openNodeScope(jjtn000);
1425 jjtreeOpenNodeScope(jjtn000);
1426 try {
1427 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1428 case EQ:
1429 jj_consume_token(EQ);
1430 break;
1431 case NE:
1432 jj_consume_token(NE);
1433 break;
1434 case EQS:
1435 jj_consume_token(EQS);
1436 break;
1437 case NEQS:
1438 jj_consume_token(NEQS);
1439 break;
1440 default:
1441 jj_la1[34] = jj_gen;
1442 jj_consume_token(-1);
1443 throw new ParseException();
1444 }
1445 } finally {
1446 if (jjtc000) {
1447 jjtree.closeNodeScope(jjtn000, true);
1448 jjtreeCloseNodeScope(jjtn000);
1449 }
1450 }
1451 }
1452
1453
1454 final public void BitwiseANDExpression() throws ParseException {
1455
1456 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1457 boolean jjtc000 = true;
1458 jjtree.openNodeScope(jjtn000);
1459 jjtreeOpenNodeScope(jjtn000);
1460 try {
1461 EqualityExpression();
1462 label_14:
1463 while (true) {
1464 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1465 case AND:
1466 ;
1467 break;
1468 default:
1469 jj_la1[35] = jj_gen;
1470 break label_14;
1471 }
1472 BitwiseANDOperator();
1473 EqualityExpression();
1474 }
1475 } catch (Throwable jjte000) {
1476 if (jjtc000) {
1477 jjtree.clearNodeScope(jjtn000);
1478 jjtc000 = false;
1479 } else {
1480 jjtree.popNode();
1481 }
1482 if (jjte000 instanceof RuntimeException) {
1483 {if (true) throw (RuntimeException)jjte000;}
1484 }
1485 if (jjte000 instanceof ParseException) {
1486 {if (true) throw (ParseException)jjte000;}
1487 }
1488 {if (true) throw (Error)jjte000;}
1489 } finally {
1490 if (jjtc000) {
1491 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1492 jjtreeCloseNodeScope(jjtn000);
1493 }
1494 }
1495 }
1496
1497 final public void BitwiseANDExpressionNoIn() throws ParseException {
1498
1499 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1500 boolean jjtc000 = true;
1501 jjtree.openNodeScope(jjtn000);
1502 jjtreeOpenNodeScope(jjtn000);
1503 try {
1504 EqualityExpressionNoIn();
1505 label_15:
1506 while (true) {
1507 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1508 case AND:
1509 ;
1510 break;
1511 default:
1512 jj_la1[36] = jj_gen;
1513 break label_15;
1514 }
1515 BitwiseANDOperator();
1516 EqualityExpressionNoIn();
1517 }
1518 } catch (Throwable jjte000) {
1519 if (jjtc000) {
1520 jjtree.clearNodeScope(jjtn000);
1521 jjtc000 = false;
1522 } else {
1523 jjtree.popNode();
1524 }
1525 if (jjte000 instanceof RuntimeException) {
1526 {if (true) throw (RuntimeException)jjte000;}
1527 }
1528 if (jjte000 instanceof ParseException) {
1529 {if (true) throw (ParseException)jjte000;}
1530 }
1531 {if (true) throw (Error)jjte000;}
1532 } finally {
1533 if (jjtc000) {
1534 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1535 jjtreeCloseNodeScope(jjtn000);
1536 }
1537 }
1538 }
1539
1540 final public void BitwiseANDOperator() throws ParseException {
1541
1542 ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1543 boolean jjtc000 = true;
1544 jjtree.openNodeScope(jjtn000);
1545 jjtreeOpenNodeScope(jjtn000);
1546 try {
1547 jj_consume_token(AND);
1548 } finally {
1549 if (jjtc000) {
1550 jjtree.closeNodeScope(jjtn000, true);
1551 jjtreeCloseNodeScope(jjtn000);
1552 }
1553 }
1554 }
1555
1556 final public void BitwiseXORExpression() throws ParseException {
1557
1558 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1559 boolean jjtc000 = true;
1560 jjtree.openNodeScope(jjtn000);
1561 jjtreeOpenNodeScope(jjtn000);
1562 try {
1563 BitwiseANDExpression();
1564 label_16:
1565 while (true) {
1566 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1567 case XOR:
1568 ;
1569 break;
1570 default:
1571 jj_la1[37] = jj_gen;
1572 break label_16;
1573 }
1574 BitwiseXOROperator();
1575 BitwiseANDExpression();
1576 }
1577 } catch (Throwable jjte000) {
1578 if (jjtc000) {
1579 jjtree.clearNodeScope(jjtn000);
1580 jjtc000 = false;
1581 } else {
1582 jjtree.popNode();
1583 }
1584 if (jjte000 instanceof RuntimeException) {
1585 {if (true) throw (RuntimeException)jjte000;}
1586 }
1587 if (jjte000 instanceof ParseException) {
1588 {if (true) throw (ParseException)jjte000;}
1589 }
1590 {if (true) throw (Error)jjte000;}
1591 } finally {
1592 if (jjtc000) {
1593 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1594 jjtreeCloseNodeScope(jjtn000);
1595 }
1596 }
1597 }
1598
1599 final public void BitwiseXORExpressionNoIn() throws ParseException {
1600
1601 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1602 boolean jjtc000 = true;
1603 jjtree.openNodeScope(jjtn000);
1604 jjtreeOpenNodeScope(jjtn000);
1605 try {
1606 BitwiseANDExpressionNoIn();
1607 label_17:
1608 while (true) {
1609 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1610 case XOR:
1611 ;
1612 break;
1613 default:
1614 jj_la1[38] = jj_gen;
1615 break label_17;
1616 }
1617 BitwiseXOROperator();
1618 BitwiseANDExpressionNoIn();
1619 }
1620 } catch (Throwable jjte000) {
1621 if (jjtc000) {
1622 jjtree.clearNodeScope(jjtn000);
1623 jjtc000 = false;
1624 } else {
1625 jjtree.popNode();
1626 }
1627 if (jjte000 instanceof RuntimeException) {
1628 {if (true) throw (RuntimeException)jjte000;}
1629 }
1630 if (jjte000 instanceof ParseException) {
1631 {if (true) throw (ParseException)jjte000;}
1632 }
1633 {if (true) throw (Error)jjte000;}
1634 } finally {
1635 if (jjtc000) {
1636 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1637 jjtreeCloseNodeScope(jjtn000);
1638 }
1639 }
1640 }
1641
1642 final public void BitwiseXOROperator() throws ParseException {
1643
1644 ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1645 boolean jjtc000 = true;
1646 jjtree.openNodeScope(jjtn000);
1647 jjtreeOpenNodeScope(jjtn000);
1648 try {
1649 jj_consume_token(XOR);
1650 } finally {
1651 if (jjtc000) {
1652 jjtree.closeNodeScope(jjtn000, true);
1653 jjtreeCloseNodeScope(jjtn000);
1654 }
1655 }
1656 }
1657
1658 final public void BitwiseORExpression() throws ParseException {
1659
1660 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1661 boolean jjtc000 = true;
1662 jjtree.openNodeScope(jjtn000);
1663 jjtreeOpenNodeScope(jjtn000);
1664 try {
1665 BitwiseXORExpression();
1666 label_18:
1667 while (true) {
1668 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1669 case OR:
1670 ;
1671 break;
1672 default:
1673 jj_la1[39] = jj_gen;
1674 break label_18;
1675 }
1676 BitwiseOROperator();
1677 BitwiseXORExpression();
1678 }
1679 } catch (Throwable jjte000) {
1680 if (jjtc000) {
1681 jjtree.clearNodeScope(jjtn000);
1682 jjtc000 = false;
1683 } else {
1684 jjtree.popNode();
1685 }
1686 if (jjte000 instanceof RuntimeException) {
1687 {if (true) throw (RuntimeException)jjte000;}
1688 }
1689 if (jjte000 instanceof ParseException) {
1690 {if (true) throw (ParseException)jjte000;}
1691 }
1692 {if (true) throw (Error)jjte000;}
1693 } finally {
1694 if (jjtc000) {
1695 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1696 jjtreeCloseNodeScope(jjtn000);
1697 }
1698 }
1699 }
1700
1701 final public void BitwiseORExpressionNoIn() throws ParseException {
1702
1703 ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1704 boolean jjtc000 = true;
1705 jjtree.openNodeScope(jjtn000);
1706 jjtreeOpenNodeScope(jjtn000);
1707 try {
1708 BitwiseXORExpressionNoIn();
1709 label_19:
1710 while (true) {
1711 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1712 case OR:
1713 ;
1714 break;
1715 default:
1716 jj_la1[40] = jj_gen;
1717 break label_19;
1718 }
1719 BitwiseOROperator();
1720 BitwiseXORExpressionNoIn();
1721 }
1722 } catch (Throwable jjte000) {
1723 if (jjtc000) {
1724 jjtree.clearNodeScope(jjtn000);
1725 jjtc000 = false;
1726 } else {
1727 jjtree.popNode();
1728 }
1729 if (jjte000 instanceof RuntimeException) {
1730 {if (true) throw (RuntimeException)jjte000;}
1731 }
1732 if (jjte000 instanceof ParseException) {
1733 {if (true) throw (ParseException)jjte000;}
1734 }
1735 {if (true) throw (Error)jjte000;}
1736 } finally {
1737 if (jjtc000) {
1738 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1739 jjtreeCloseNodeScope(jjtn000);
1740 }
1741 }
1742 }
1743
1744 final public void BitwiseOROperator() throws ParseException {
1745
1746 ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1747 boolean jjtc000 = true;
1748 jjtree.openNodeScope(jjtn000);
1749 jjtreeOpenNodeScope(jjtn000);
1750 try {
1751 jj_consume_token(OR);
1752 } finally {
1753 if (jjtc000) {
1754 jjtree.closeNodeScope(jjtn000, true);
1755 jjtreeCloseNodeScope(jjtn000);
1756 }
1757 }
1758 }
1759
1760
1761 final public void LogicalANDExpression() throws ParseException {
1762
1763 ECMAAndOperation jjtn000 = new ECMAAndOperation(this, JJTANDOPERATION);
1764 boolean jjtc000 = true;
1765 jjtree.openNodeScope(jjtn000);
1766 jjtreeOpenNodeScope(jjtn000);
1767 try {
1768 BitwiseORExpression();
1769 label_20:
1770 while (true) {
1771 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1772 case BAND:
1773 ;
1774 break;
1775 default:
1776 jj_la1[41] = jj_gen;
1777 break label_20;
1778 }
1779 LogicalANDOperator();
1780 BitwiseORExpression();
1781 }
1782 } catch (Throwable jjte000) {
1783 if (jjtc000) {
1784 jjtree.clearNodeScope(jjtn000);
1785 jjtc000 = false;
1786 } else {
1787 jjtree.popNode();
1788 }
1789 if (jjte000 instanceof RuntimeException) {
1790 {if (true) throw (RuntimeException)jjte000;}
1791 }
1792 if (jjte000 instanceof ParseException) {
1793 {if (true) throw (ParseException)jjte000;}
1794 }
1795 {if (true) throw (Error)jjte000;}
1796 } finally {
1797 if (jjtc000) {
1798 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1799 jjtreeCloseNodeScope(jjtn000);
1800 }
1801 }
1802 }
1803
1804 final public void LogicalANDExpressionNoIn() throws ParseException {
1805
1806 ECMAAndOperation jjtn000 = new ECMAAndOperation(this, JJTANDOPERATION);
1807 boolean jjtc000 = true;
1808 jjtree.openNodeScope(jjtn000);
1809 jjtreeOpenNodeScope(jjtn000);
1810 try {
1811 BitwiseORExpressionNoIn();
1812 label_21:
1813 while (true) {
1814 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1815 case BAND:
1816 ;
1817 break;
1818 default:
1819 jj_la1[42] = jj_gen;
1820 break label_21;
1821 }
1822 LogicalANDOperator();
1823 BitwiseORExpressionNoIn();
1824 }
1825 } catch (Throwable jjte000) {
1826 if (jjtc000) {
1827 jjtree.clearNodeScope(jjtn000);
1828 jjtc000 = false;
1829 } else {
1830 jjtree.popNode();
1831 }
1832 if (jjte000 instanceof RuntimeException) {
1833 {if (true) throw (RuntimeException)jjte000;}
1834 }
1835 if (jjte000 instanceof ParseException) {
1836 {if (true) throw (ParseException)jjte000;}
1837 }
1838 {if (true) throw (Error)jjte000;}
1839 } finally {
1840 if (jjtc000) {
1841 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1842 jjtreeCloseNodeScope(jjtn000);
1843 }
1844 }
1845 }
1846
1847 final public void LogicalANDOperator() throws ParseException {
1848
1849 ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1850 boolean jjtc000 = true;
1851 jjtree.openNodeScope(jjtn000);
1852 jjtreeOpenNodeScope(jjtn000);
1853 try {
1854 jj_consume_token(BAND);
1855 } finally {
1856 if (jjtc000) {
1857 jjtree.closeNodeScope(jjtn000, true);
1858 jjtreeCloseNodeScope(jjtn000);
1859 }
1860 }
1861 }
1862
1863 final public void LogicalORExpression() throws ParseException {
1864
1865 ECMAOrOperation jjtn000 = new ECMAOrOperation(this, JJTOROPERATION);
1866 boolean jjtc000 = true;
1867 jjtree.openNodeScope(jjtn000);
1868 jjtreeOpenNodeScope(jjtn000);
1869 try {
1870 LogicalANDExpression();
1871 label_22:
1872 while (true) {
1873 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1874 case BOR:
1875 ;
1876 break;
1877 default:
1878 jj_la1[43] = jj_gen;
1879 break label_22;
1880 }
1881 LogicalOROperator();
1882 LogicalANDExpression();
1883 }
1884 } catch (Throwable jjte000) {
1885 if (jjtc000) {
1886 jjtree.clearNodeScope(jjtn000);
1887 jjtc000 = false;
1888 } else {
1889 jjtree.popNode();
1890 }
1891 if (jjte000 instanceof RuntimeException) {
1892 {if (true) throw (RuntimeException)jjte000;}
1893 }
1894 if (jjte000 instanceof ParseException) {
1895 {if (true) throw (ParseException)jjte000;}
1896 }
1897 {if (true) throw (Error)jjte000;}
1898 } finally {
1899 if (jjtc000) {
1900 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1901 jjtreeCloseNodeScope(jjtn000);
1902 }
1903 }
1904 }
1905
1906 final public void LogicalORExpressionNoIn() throws ParseException {
1907
1908 ECMAOrOperation jjtn000 = new ECMAOrOperation(this, JJTOROPERATION);
1909 boolean jjtc000 = true;
1910 jjtree.openNodeScope(jjtn000);
1911 jjtreeOpenNodeScope(jjtn000);
1912 try {
1913 LogicalANDExpressionNoIn();
1914 label_23:
1915 while (true) {
1916 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1917 case BOR:
1918 ;
1919 break;
1920 default:
1921 jj_la1[44] = jj_gen;
1922 break label_23;
1923 }
1924 LogicalOROperator();
1925 LogicalANDExpressionNoIn();
1926 }
1927 } catch (Throwable jjte000) {
1928 if (jjtc000) {
1929 jjtree.clearNodeScope(jjtn000);
1930 jjtc000 = false;
1931 } else {
1932 jjtree.popNode();
1933 }
1934 if (jjte000 instanceof RuntimeException) {
1935 {if (true) throw (RuntimeException)jjte000;}
1936 }
1937 if (jjte000 instanceof ParseException) {
1938 {if (true) throw (ParseException)jjte000;}
1939 }
1940 {if (true) throw (Error)jjte000;}
1941 } finally {
1942 if (jjtc000) {
1943 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1944 jjtreeCloseNodeScope(jjtn000);
1945 }
1946 }
1947 }
1948
1949 final public void LogicalOROperator() throws ParseException {
1950
1951 ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1952 boolean jjtc000 = true;
1953 jjtree.openNodeScope(jjtn000);
1954 jjtreeOpenNodeScope(jjtn000);
1955 try {
1956 jj_consume_token(BOR);
1957 } finally {
1958 if (jjtc000) {
1959 jjtree.closeNodeScope(jjtn000, true);
1960 jjtreeCloseNodeScope(jjtn000);
1961 }
1962 }
1963 }
1964
1965
1966 final public void ConditionalExpression() throws ParseException {
1967
1968 ECMAConditionalExpression jjtn000 = new ECMAConditionalExpression(this, JJTCONDITIONALEXPRESSION);
1969 boolean jjtc000 = true;
1970 jjtree.openNodeScope(jjtn000);
1971 jjtreeOpenNodeScope(jjtn000);
1972 try {
1973 LogicalORExpression();
1974 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1975 case QUEST:
1976 jj_consume_token(QUEST);
1977 AssignmentExpression();
1978 jj_consume_token(COLON);
1979 AssignmentExpression();
1980 break;
1981 default:
1982 jj_la1[45] = jj_gen;
1983 ;
1984 }
1985 } catch (Throwable jjte000) {
1986 if (jjtc000) {
1987 jjtree.clearNodeScope(jjtn000);
1988 jjtc000 = false;
1989 } else {
1990 jjtree.popNode();
1991 }
1992 if (jjte000 instanceof RuntimeException) {
1993 {if (true) throw (RuntimeException)jjte000;}
1994 }
1995 if (jjte000 instanceof ParseException) {
1996 {if (true) throw (ParseException)jjte000;}
1997 }
1998 {if (true) throw (Error)jjte000;}
1999 } finally {
2000 if (jjtc000) {
2001 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2002 jjtreeCloseNodeScope(jjtn000);
2003 }
2004 }
2005 }
2006
2007 final public void ConditionalExpressionNoIn() throws ParseException {
2008
2009 ECMAConditionalExpression jjtn000 = new ECMAConditionalExpression(this, JJTCONDITIONALEXPRESSION);
2010 boolean jjtc000 = true;
2011 jjtree.openNodeScope(jjtn000);
2012 jjtreeOpenNodeScope(jjtn000);
2013 try {
2014 LogicalORExpressionNoIn();
2015 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2016 case QUEST:
2017 jj_consume_token(QUEST);
2018 AssignmentExpression();
2019 jj_consume_token(COLON);
2020 AssignmentExpressionNoIn();
2021 break;
2022 default:
2023 jj_la1[46] = jj_gen;
2024 ;
2025 }
2026 } catch (Throwable jjte000) {
2027 if (jjtc000) {
2028 jjtree.clearNodeScope(jjtn000);
2029 jjtc000 = false;
2030 } else {
2031 jjtree.popNode();
2032 }
2033 if (jjte000 instanceof RuntimeException) {
2034 {if (true) throw (RuntimeException)jjte000;}
2035 }
2036 if (jjte000 instanceof ParseException) {
2037 {if (true) throw (ParseException)jjte000;}
2038 }
2039 {if (true) throw (Error)jjte000;}
2040 } finally {
2041 if (jjtc000) {
2042 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2043 jjtreeCloseNodeScope(jjtn000);
2044 }
2045 }
2046 }
2047
2048
2049 final public void AssignmentExpression() throws ParseException {
2050
2051 ECMAAssignmentExpression jjtn000 = new ECMAAssignmentExpression(this, JJTASSIGNMENTEXPRESSION);
2052 boolean jjtc000 = true;
2053 jjtree.openNodeScope(jjtn000);
2054 jjtreeOpenNodeScope(jjtn000);
2055 try {
2056 if (jj_2_14(2147483647)) {
2057 LeftHandSideExpression();
2058 AssignmentOperator();
2059 AssignmentExpression();
2060 } else {
2061 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2062 case TYPEOF:
2063 case NEW:
2064 case VOID:
2065 case FUNCTION:
2066 case THIS:
2067 case DELETE:
2068 case LBRACE:
2069 case LPAREN:
2070 case LBRACKET:
2071 case PLUS:
2072 case MINUS:
2073 case INC:
2074 case DEC:
2075 case BNOT:
2076 case NOT:
2077 case NULL_LITERAL:
2078 case BOOLEAN_LITERAL:
2079 case DECIMAL_LITERAL:
2080 case HEX_INTEGER_LITERAL:
2081 case STRING_LITERAL:
2082 case IDENTIFIER_NAME:
2083 case REGULAR_EXPRESSION_LITERAL:
2084 ConditionalExpression();
2085 break;
2086 default:
2087 jj_la1[47] = jj_gen;
2088 jj_consume_token(-1);
2089 throw new ParseException();
2090 }
2091 }
2092 } catch (Throwable jjte000) {
2093 if (jjtc000) {
2094 jjtree.clearNodeScope(jjtn000);
2095 jjtc000 = false;
2096 } else {
2097 jjtree.popNode();
2098 }
2099 if (jjte000 instanceof RuntimeException) {
2100 {if (true) throw (RuntimeException)jjte000;}
2101 }
2102 if (jjte000 instanceof ParseException) {
2103 {if (true) throw (ParseException)jjte000;}
2104 }
2105 {if (true) throw (Error)jjte000;}
2106 } finally {
2107 if (jjtc000) {
2108 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2109 jjtreeCloseNodeScope(jjtn000);
2110 }
2111 }
2112 }
2113
2114 final public void AssignmentExpressionNoIn() throws ParseException {
2115
2116 ECMAAssignmentExpression jjtn000 = new ECMAAssignmentExpression(this, JJTASSIGNMENTEXPRESSION);
2117 boolean jjtc000 = true;
2118 jjtree.openNodeScope(jjtn000);
2119 jjtreeOpenNodeScope(jjtn000);
2120 try {
2121 if (jj_2_15(2147483647)) {
2122 LeftHandSideExpression();
2123 AssignmentOperator();
2124 AssignmentExpressionNoIn();
2125 } else {
2126 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2127 case TYPEOF:
2128 case NEW:
2129 case VOID:
2130 case FUNCTION:
2131 case THIS:
2132 case DELETE:
2133 case LBRACE:
2134 case LPAREN:
2135 case LBRACKET:
2136 case PLUS:
2137 case MINUS:
2138 case INC:
2139 case DEC:
2140 case BNOT:
2141 case NOT:
2142 case NULL_LITERAL:
2143 case BOOLEAN_LITERAL:
2144 case DECIMAL_LITERAL:
2145 case HEX_INTEGER_LITERAL:
2146 case STRING_LITERAL:
2147 case IDENTIFIER_NAME:
2148 case REGULAR_EXPRESSION_LITERAL:
2149 ConditionalExpressionNoIn();
2150 break;
2151 default:
2152 jj_la1[48] = jj_gen;
2153 jj_consume_token(-1);
2154 throw new ParseException();
2155 }
2156 }
2157 } catch (Throwable jjte000) {
2158 if (jjtc000) {
2159 jjtree.clearNodeScope(jjtn000);
2160 jjtc000 = false;
2161 } else {
2162 jjtree.popNode();
2163 }
2164 if (jjte000 instanceof RuntimeException) {
2165 {if (true) throw (RuntimeException)jjte000;}
2166 }
2167 if (jjte000 instanceof ParseException) {
2168 {if (true) throw (ParseException)jjte000;}
2169 }
2170 {if (true) throw (Error)jjte000;}
2171 } finally {
2172 if (jjtc000) {
2173 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2174 jjtreeCloseNodeScope(jjtn000);
2175 }
2176 }
2177 }
2178
2179 final public void AssignmentOperator() throws ParseException {
2180
2181 ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
2182 boolean jjtc000 = true;
2183 jjtree.openNodeScope(jjtn000);
2184 jjtreeOpenNodeScope(jjtn000);
2185 try {
2186 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2187 case ASSIGN:
2188 jj_consume_token(ASSIGN);
2189 break;
2190 case AMUL:
2191 jj_consume_token(AMUL);
2192 break;
2193 case ADIV:
2194 jj_consume_token(ADIV);
2195 break;
2196 case AMOD:
2197 jj_consume_token(AMOD);
2198 break;
2199 case AADD:
2200 jj_consume_token(AADD);
2201 break;
2202 case ASUB:
2203 jj_consume_token(ASUB);
2204 break;
2205 case ASHL:
2206 jj_consume_token(ASHL);
2207 break;
2208 case ASHR:
2209 jj_consume_token(ASHR);
2210 break;
2211 case ASHRU:
2212 jj_consume_token(ASHRU);
2213 break;
2214 case AAND:
2215 jj_consume_token(AAND);
2216 break;
2217 case AXOR:
2218 jj_consume_token(AXOR);
2219 break;
2220 case AOR:
2221 jj_consume_token(AOR);
2222 break;
2223 default:
2224 jj_la1[49] = jj_gen;
2225 jj_consume_token(-1);
2226 throw new ParseException();
2227 }
2228 } finally {
2229 if (jjtc000) {
2230 jjtree.closeNodeScope(jjtn000, true);
2231 jjtreeCloseNodeScope(jjtn000);
2232 }
2233 }
2234 }
2235
2236
2237 final public void Expression() throws ParseException {
2238
2239 ECMACommaExpression jjtn000 = new ECMACommaExpression(this, JJTCOMMAEXPRESSION);
2240 boolean jjtc000 = true;
2241 jjtree.openNodeScope(jjtn000);
2242 jjtreeOpenNodeScope(jjtn000);
2243 try {
2244 AssignmentExpression();
2245 label_24:
2246 while (true) {
2247 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2248 case COMMA:
2249 ;
2250 break;
2251 default:
2252 jj_la1[50] = jj_gen;
2253 break label_24;
2254 }
2255 jj_consume_token(COMMA);
2256 AssignmentExpression();
2257 }
2258 } catch (Throwable jjte000) {
2259 if (jjtc000) {
2260 jjtree.clearNodeScope(jjtn000);
2261 jjtc000 = false;
2262 } else {
2263 jjtree.popNode();
2264 }
2265 if (jjte000 instanceof RuntimeException) {
2266 {if (true) throw (RuntimeException)jjte000;}
2267 }
2268 if (jjte000 instanceof ParseException) {
2269 {if (true) throw (ParseException)jjte000;}
2270 }
2271 {if (true) throw (Error)jjte000;}
2272 } finally {
2273 if (jjtc000) {
2274 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2275 jjtreeCloseNodeScope(jjtn000);
2276 }
2277 }
2278 }
2279
2280 final public void ExpressionNoIn() throws ParseException {
2281
2282 ECMACommaExpression jjtn000 = new ECMACommaExpression(this, JJTCOMMAEXPRESSION);
2283 boolean jjtc000 = true;
2284 jjtree.openNodeScope(jjtn000);
2285 jjtreeOpenNodeScope(jjtn000);
2286 try {
2287 AssignmentExpressionNoIn();
2288 label_25:
2289 while (true) {
2290 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2291 case COMMA:
2292 ;
2293 break;
2294 default:
2295 jj_la1[51] = jj_gen;
2296 break label_25;
2297 }
2298 jj_consume_token(COMMA);
2299 AssignmentExpressionNoIn();
2300 }
2301 } catch (Throwable jjte000) {
2302 if (jjtc000) {
2303 jjtree.clearNodeScope(jjtn000);
2304 jjtc000 = false;
2305 } else {
2306 jjtree.popNode();
2307 }
2308 if (jjte000 instanceof RuntimeException) {
2309 {if (true) throw (RuntimeException)jjte000;}
2310 }
2311 if (jjte000 instanceof ParseException) {
2312 {if (true) throw (ParseException)jjte000;}
2313 }
2314 {if (true) throw (Error)jjte000;}
2315 } finally {
2316 if (jjtc000) {
2317 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2318 jjtreeCloseNodeScope(jjtn000);
2319 }
2320 }
2321 }
2322
2323
2324 final public void Statement() throws ParseException {
2325 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2326 case JAVA_STATEMENT:
2327 ECMAJavaStatement jjtn001 = new ECMAJavaStatement(this, JJTJAVASTATEMENT);
2328 boolean jjtc001 = true;
2329 jjtree.openNodeScope(jjtn001);
2330 jjtreeOpenNodeScope(jjtn001);
2331 try {
2332 jj_consume_token(JAVA_STATEMENT);
2333 } finally {
2334 if (jjtc001) {
2335 jjtree.closeNodeScope(jjtn001, true);
2336 jjtreeCloseNodeScope(jjtn001);
2337 }
2338 }
2339 break;
2340 default:
2341 jj_la1[52] = jj_gen;
2342 if (jj_2_16(2147483647)) {
2343 Block();
2344 } else if (jj_2_17(2147483647)) {
2345 VariableStatement();
2346 } else {
2347 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2348 case DEBUGGER:
2349 DebuggerStatement();
2350 break;
2351 case SEMICOLON:
2352 EmptyStatement();
2353 break;
2354 default:
2355 jj_la1[53] = jj_gen;
2356 if (jj_2_18(2147483647)) {
2357 LabelledStatement();
2358 } else if (jj_2_19(2147483647)) {
2359 ExpressionStatement();
2360 } else if (jj_2_20(2147483647)) {
2361 IfStatement();
2362 } else {
2363 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2364 case DO:
2365 case FOR:
2366 case WHILE:
2367 IterationStatement();
2368 break;
2369 default:
2370 jj_la1[54] = jj_gen;
2371 if (jj_2_21(2147483647)) {
2372 ContinueStatement();
2373 } else if (jj_2_22(2147483647)) {
2374 BreakStatement();
2375 } else {
2376 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2377 case RETURN:
2378 ReturnStatement();
2379 break;
2380 case WITH:
2381 WithStatement();
2382 break;
2383 case SWITCH:
2384 SwitchStatement();
2385 break;
2386 case THROW:
2387 ThrowStatement();
2388 break;
2389 case TRY:
2390 TryStatement();
2391 break;
2392 default:
2393 jj_la1[55] = jj_gen;
2394 jj_consume_token(-1);
2395 throw new ParseException();
2396 }
2397 }
2398 }
2399 }
2400 }
2401 }
2402 }
2403 }
2404
2405
2406 final public void Block() throws ParseException {
2407
2408 ECMABlock jjtn000 = new ECMABlock(this, JJTBLOCK);
2409 boolean jjtc000 = true;
2410 jjtree.openNodeScope(jjtn000);
2411 jjtreeOpenNodeScope(jjtn000);
2412 try {
2413 jj_consume_token(LBRACE);
2414 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2415 case BREAK:
2416 case DO:
2417 case TYPEOF:
2418 case NEW:
2419 case VAR:
2420 case RETURN:
2421 case VOID:
2422 case CONTINUE:
2423 case FOR:
2424 case SWITCH:
2425 case WHILE:
2426 case DEBUGGER:
2427 case FUNCTION:
2428 case THIS:
2429 case WITH:
2430 case IF:
2431 case THROW:
2432 case DELETE:
2433 case TRY:
2434 case LBRACE:
2435 case LPAREN:
2436 case LBRACKET:
2437 case SEMICOLON:
2438 case PLUS:
2439 case MINUS:
2440 case INC:
2441 case DEC:
2442 case BNOT:
2443 case NOT:
2444 case NULL_LITERAL:
2445 case BOOLEAN_LITERAL:
2446 case DECIMAL_LITERAL:
2447 case HEX_INTEGER_LITERAL:
2448 case STRING_LITERAL:
2449 case IDENTIFIER_NAME:
2450 case REGULAR_EXPRESSION_LITERAL:
2451 case JAVA_STATEMENT:
2452 StatementList();
2453 break;
2454 default:
2455 jj_la1[56] = jj_gen;
2456 ;
2457 }
2458 jj_consume_token(RBRACE);
2459 } catch (Throwable jjte000) {
2460 if (jjtc000) {
2461 jjtree.clearNodeScope(jjtn000);
2462 jjtc000 = false;
2463 } else {
2464 jjtree.popNode();
2465 }
2466 if (jjte000 instanceof RuntimeException) {
2467 {if (true) throw (RuntimeException)jjte000;}
2468 }
2469 if (jjte000 instanceof ParseException) {
2470 {if (true) throw (ParseException)jjte000;}
2471 }
2472 {if (true) throw (Error)jjte000;}
2473 } finally {
2474 if (jjtc000) {
2475 jjtree.closeNodeScope(jjtn000, true);
2476 jjtreeCloseNodeScope(jjtn000);
2477 }
2478 }
2479 }
2480
2481 final public void StatementList() throws ParseException {
2482
2483 ECMAStatementList jjtn000 = new ECMAStatementList(this, JJTSTATEMENTLIST);
2484 boolean jjtc000 = true;
2485 jjtree.openNodeScope(jjtn000);
2486 jjtreeOpenNodeScope(jjtn000);
2487 try {
2488 label_26:
2489 while (true) {
2490 Statement();
2491 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2492 case BREAK:
2493 case DO:
2494 case TYPEOF:
2495 case NEW:
2496 case VAR:
2497 case RETURN:
2498 case VOID:
2499 case CONTINUE:
2500 case FOR:
2501 case SWITCH:
2502 case WHILE:
2503 case DEBUGGER:
2504 case FUNCTION:
2505 case THIS:
2506 case WITH:
2507 case IF:
2508 case THROW:
2509 case DELETE:
2510 case TRY:
2511 case LBRACE:
2512 case LPAREN:
2513 case LBRACKET:
2514 case SEMICOLON:
2515 case PLUS:
2516 case MINUS:
2517 case INC:
2518 case DEC:
2519 case BNOT:
2520 case NOT:
2521 case NULL_LITERAL:
2522 case BOOLEAN_LITERAL:
2523 case DECIMAL_LITERAL:
2524 case HEX_INTEGER_LITERAL:
2525 case STRING_LITERAL:
2526 case IDENTIFIER_NAME:
2527 case REGULAR_EXPRESSION_LITERAL:
2528 case JAVA_STATEMENT:
2529 ;
2530 break;
2531 default:
2532 jj_la1[57] = jj_gen;
2533 break label_26;
2534 }
2535 }
2536 } catch (Throwable jjte000) {
2537 if (jjtc000) {
2538 jjtree.clearNodeScope(jjtn000);
2539 jjtc000 = false;
2540 } else {
2541 jjtree.popNode();
2542 }
2543 if (jjte000 instanceof RuntimeException) {
2544 {if (true) throw (RuntimeException)jjte000;}
2545 }
2546 if (jjte000 instanceof ParseException) {
2547 {if (true) throw (ParseException)jjte000;}
2548 }
2549 {if (true) throw (Error)jjte000;}
2550 } finally {
2551 if (jjtc000) {
2552 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2553 jjtreeCloseNodeScope(jjtn000);
2554 }
2555 }
2556 }
2557
2558
2559 final public void VariableStatement() throws ParseException {
2560
2561 ECMAVariableStatement jjtn000 = new ECMAVariableStatement(this, JJTVARIABLESTATEMENT);
2562 boolean jjtc000 = true;
2563 jjtree.openNodeScope(jjtn000);
2564 jjtreeOpenNodeScope(jjtn000);
2565 try {
2566 jj_consume_token(VAR);
2567 VariableDeclarationList();
2568 if (jj_2_23(2)) {
2569 jj_consume_token(SEMICOLON);
2570 } else {
2571 ;
2572 }
2573 } catch (Throwable jjte000) {
2574 if (jjtc000) {
2575 jjtree.clearNodeScope(jjtn000);
2576 jjtc000 = false;
2577 } else {
2578 jjtree.popNode();
2579 }
2580 if (jjte000 instanceof RuntimeException) {
2581 {if (true) throw (RuntimeException)jjte000;}
2582 }
2583 if (jjte000 instanceof ParseException) {
2584 {if (true) throw (ParseException)jjte000;}
2585 }
2586 {if (true) throw (Error)jjte000;}
2587 } finally {
2588 if (jjtc000) {
2589 jjtree.closeNodeScope(jjtn000, true);
2590 jjtreeCloseNodeScope(jjtn000);
2591 }
2592 }
2593 }
2594
2595 final public void VariableDeclarationList() throws ParseException {
2596
2597 ECMAVariableDeclarationList jjtn000 = new ECMAVariableDeclarationList(this, JJTVARIABLEDECLARATIONLIST);
2598 boolean jjtc000 = true;
2599 jjtree.openNodeScope(jjtn000);
2600 jjtreeOpenNodeScope(jjtn000);
2601 try {
2602 VariableDeclaration();
2603 label_27:
2604 while (true) {
2605 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2606 case COMMA:
2607 ;
2608 break;
2609 default:
2610 jj_la1[58] = jj_gen;
2611 break label_27;
2612 }
2613 jj_consume_token(COMMA);
2614 VariableDeclaration();
2615 }
2616 } catch (Throwable jjte000) {
2617 if (jjtc000) {
2618 jjtree.clearNodeScope(jjtn000);
2619 jjtc000 = false;
2620 } else {
2621 jjtree.popNode();
2622 }
2623 if (jjte000 instanceof RuntimeException) {
2624 {if (true) throw (RuntimeException)jjte000;}
2625 }
2626 if (jjte000 instanceof ParseException) {
2627 {if (true) throw (ParseException)jjte000;}
2628 }
2629 {if (true) throw (Error)jjte000;}
2630 } finally {
2631 if (jjtc000) {
2632 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2633 jjtreeCloseNodeScope(jjtn000);
2634 }
2635 }
2636 }
2637
2638 final public void VariableDeclarationListNoIn() throws ParseException {
2639
2640 ECMAVariableDeclarationList jjtn000 = new ECMAVariableDeclarationList(this, JJTVARIABLEDECLARATIONLIST);
2641 boolean jjtc000 = true;
2642 jjtree.openNodeScope(jjtn000);
2643 jjtreeOpenNodeScope(jjtn000);
2644 try {
2645 VariableDeclarationNoIn();
2646 label_28:
2647 while (true) {
2648 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2649 case COMMA:
2650 ;
2651 break;
2652 default:
2653 jj_la1[59] = jj_gen;
2654 break label_28;
2655 }
2656 jj_consume_token(COMMA);
2657 VariableDeclarationNoIn();
2658 }
2659 } catch (Throwable jjte000) {
2660 if (jjtc000) {
2661 jjtree.clearNodeScope(jjtn000);
2662 jjtc000 = false;
2663 } else {
2664 jjtree.popNode();
2665 }
2666 if (jjte000 instanceof RuntimeException) {
2667 {if (true) throw (RuntimeException)jjte000;}
2668 }
2669 if (jjte000 instanceof ParseException) {
2670 {if (true) throw (ParseException)jjte000;}
2671 }
2672 {if (true) throw (Error)jjte000;}
2673 } finally {
2674 if (jjtc000) {
2675 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2676 jjtreeCloseNodeScope(jjtn000);
2677 }
2678 }
2679 }
2680
2681 final public void VariableDeclaration() throws ParseException {
2682
2683 ECMAVariableDeclaration jjtn000 = new ECMAVariableDeclaration(this, JJTVARIABLEDECLARATION);
2684 boolean jjtc000 = true;
2685 jjtree.openNodeScope(jjtn000);
2686 jjtreeOpenNodeScope(jjtn000);
2687 try {
2688 Identifier();
2689 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2690 case ASSIGN:
2691 Initialiser();
2692 break;
2693 default:
2694 jj_la1[60] = jj_gen;
2695 ;
2696 }
2697 } catch (Throwable jjte000) {
2698 if (jjtc000) {
2699 jjtree.clearNodeScope(jjtn000);
2700 jjtc000 = false;
2701 } else {
2702 jjtree.popNode();
2703 }
2704 if (jjte000 instanceof RuntimeException) {
2705 {if (true) throw (RuntimeException)jjte000;}
2706 }
2707 if (jjte000 instanceof ParseException) {
2708 {if (true) throw (ParseException)jjte000;}
2709 }
2710 {if (true) throw (Error)jjte000;}
2711 } finally {
2712 if (jjtc000) {
2713 jjtree.closeNodeScope(jjtn000, true);
2714 jjtreeCloseNodeScope(jjtn000);
2715 }
2716 }
2717 }
2718
2719 final public void VariableDeclarationNoIn() throws ParseException {
2720
2721 ECMAVariableDeclaration jjtn000 = new ECMAVariableDeclaration(this, JJTVARIABLEDECLARATION);
2722 boolean jjtc000 = true;
2723 jjtree.openNodeScope(jjtn000);
2724 jjtreeOpenNodeScope(jjtn000);
2725 try {
2726 Identifier();
2727 ECMAEmptyExpression jjtn001 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2728 boolean jjtc001 = true;
2729 jjtree.openNodeScope(jjtn001);
2730 jjtreeOpenNodeScope(jjtn001);
2731 try {
2732 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2733 case ASSIGN:
2734 InitialiserNoIn();
2735 break;
2736 default:
2737 jj_la1[61] = jj_gen;
2738 ;
2739 }
2740 } catch (Throwable jjte001) {
2741 if (jjtc001) {
2742 jjtree.clearNodeScope(jjtn001);
2743 jjtc001 = false;
2744 } else {
2745 jjtree.popNode();
2746 }
2747 if (jjte001 instanceof RuntimeException) {
2748 {if (true) throw (RuntimeException)jjte001;}
2749 }
2750 if (jjte001 instanceof ParseException) {
2751 {if (true) throw (ParseException)jjte001;}
2752 }
2753 {if (true) throw (Error)jjte001;}
2754 } finally {
2755 if (jjtc001) {
2756 jjtree.closeNodeScope(jjtn001, jjtree . nodeArity ( ) == 0);
2757 jjtreeCloseNodeScope(jjtn001);
2758 }
2759 }
2760 } catch (Throwable jjte000) {
2761 if (jjtc000) {
2762 jjtree.clearNodeScope(jjtn000);
2763 jjtc000 = false;
2764 } else {
2765 jjtree.popNode();
2766 }
2767 if (jjte000 instanceof RuntimeException) {
2768 {if (true) throw (RuntimeException)jjte000;}
2769 }
2770 if (jjte000 instanceof ParseException) {
2771 {if (true) throw (ParseException)jjte000;}
2772 }
2773 {if (true) throw (Error)jjte000;}
2774 } finally {
2775 if (jjtc000) {
2776 jjtree.closeNodeScope(jjtn000, true);
2777 jjtreeCloseNodeScope(jjtn000);
2778 }
2779 }
2780 }
2781
2782 final public void Initialiser() throws ParseException {
2783 jj_consume_token(ASSIGN);
2784 AssignmentExpression();
2785 }
2786
2787 final public void InitialiserNoIn() throws ParseException {
2788 jj_consume_token(ASSIGN);
2789 AssignmentExpressionNoIn();
2790 }
2791
2792
2793 final public void EmptyStatement() throws ParseException {
2794 jj_consume_token(SEMICOLON);
2795 }
2796
2797
2798 final public void ExpressionStatement() throws ParseException {
2799
2800 ECMAExpressionStatement jjtn000 = new ECMAExpressionStatement(this, JJTEXPRESSIONSTATEMENT);
2801 boolean jjtc000 = true;
2802 jjtree.openNodeScope(jjtn000);
2803 jjtreeOpenNodeScope(jjtn000);
2804 try {
2805 Expression();
2806 if (jj_2_24(2)) {
2807 jj_consume_token(SEMICOLON);
2808 } else {
2809 ;
2810 }
2811 } catch (Throwable jjte000) {
2812 if (jjtc000) {
2813 jjtree.clearNodeScope(jjtn000);
2814 jjtc000 = false;
2815 } else {
2816 jjtree.popNode();
2817 }
2818 if (jjte000 instanceof RuntimeException) {
2819 {if (true) throw (RuntimeException)jjte000;}
2820 }
2821 if (jjte000 instanceof ParseException) {
2822 {if (true) throw (ParseException)jjte000;}
2823 }
2824 {if (true) throw (Error)jjte000;}
2825 } finally {
2826 if (jjtc000) {
2827 jjtree.closeNodeScope(jjtn000, true);
2828 jjtreeCloseNodeScope(jjtn000);
2829 }
2830 }
2831 }
2832
2833
2834 final public void IfStatement() throws ParseException {
2835
2836 ECMAIfStatement jjtn000 = new ECMAIfStatement(this, JJTIFSTATEMENT);
2837 boolean jjtc000 = true;
2838 jjtree.openNodeScope(jjtn000);
2839 jjtreeOpenNodeScope(jjtn000);
2840 try {
2841 jj_consume_token(IF);
2842 jj_consume_token(LPAREN);
2843 Expression();
2844 jj_consume_token(RPAREN);
2845 Statement();
2846 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2847 case ELSE:
2848 jj_consume_token(ELSE);
2849 Statement();
2850 break;
2851 default:
2852 jj_la1[62] = jj_gen;
2853 ;
2854 }
2855 } catch (Throwable jjte000) {
2856 if (jjtc000) {
2857 jjtree.clearNodeScope(jjtn000);
2858 jjtc000 = false;
2859 } else {
2860 jjtree.popNode();
2861 }
2862 if (jjte000 instanceof RuntimeException) {
2863 {if (true) throw (RuntimeException)jjte000;}
2864 }
2865 if (jjte000 instanceof ParseException) {
2866 {if (true) throw (ParseException)jjte000;}
2867 }
2868 {if (true) throw (Error)jjte000;}
2869 } finally {
2870 if (jjtc000) {
2871 jjtree.closeNodeScope(jjtn000, true);
2872 jjtreeCloseNodeScope(jjtn000);
2873 }
2874 }
2875 }
2876
2877
2878 final public void IterationStatement() throws ParseException {
2879 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2880 case DO:
2881 ECMADoWhileStatement jjtn001 = new ECMADoWhileStatement(this, JJTDOWHILESTATEMENT);
2882 boolean jjtc001 = true;
2883 jjtree.openNodeScope(jjtn001);
2884 jjtreeOpenNodeScope(jjtn001);
2885 try {
2886 jj_consume_token(DO);
2887 Statement();
2888 jj_consume_token(WHILE);
2889 jj_consume_token(LPAREN);
2890 Expression();
2891 jj_consume_token(RPAREN);
2892 if (jj_2_25(2)) {
2893 jj_consume_token(SEMICOLON);
2894 } else {
2895 ;
2896 }
2897 } catch (Throwable jjte001) {
2898 if (jjtc001) {
2899 jjtree.clearNodeScope(jjtn001);
2900 jjtc001 = false;
2901 } else {
2902 jjtree.popNode();
2903 }
2904 if (jjte001 instanceof RuntimeException) {
2905 {if (true) throw (RuntimeException)jjte001;}
2906 }
2907 if (jjte001 instanceof ParseException) {
2908 {if (true) throw (ParseException)jjte001;}
2909 }
2910 {if (true) throw (Error)jjte001;}
2911 } finally {
2912 if (jjtc001) {
2913 jjtree.closeNodeScope(jjtn001, true);
2914 jjtreeCloseNodeScope(jjtn001);
2915 }
2916 }
2917 break;
2918 case WHILE:
2919 ECMAWhileStatement jjtn002 = new ECMAWhileStatement(this, JJTWHILESTATEMENT);
2920 boolean jjtc002 = true;
2921 jjtree.openNodeScope(jjtn002);
2922 jjtreeOpenNodeScope(jjtn002);
2923 try {
2924 jj_consume_token(WHILE);
2925 jj_consume_token(LPAREN);
2926 Expression();
2927 jj_consume_token(RPAREN);
2928 Statement();
2929 } catch (Throwable jjte002) {
2930 if (jjtc002) {
2931 jjtree.clearNodeScope(jjtn002);
2932 jjtc002 = false;
2933 } else {
2934 jjtree.popNode();
2935 }
2936 if (jjte002 instanceof RuntimeException) {
2937 {if (true) throw (RuntimeException)jjte002;}
2938 }
2939 if (jjte002 instanceof ParseException) {
2940 {if (true) throw (ParseException)jjte002;}
2941 }
2942 {if (true) throw (Error)jjte002;}
2943 } finally {
2944 if (jjtc002) {
2945 jjtree.closeNodeScope(jjtn002, true);
2946 jjtreeCloseNodeScope(jjtn002);
2947 }
2948 }
2949 break;
2950 default:
2951 jj_la1[68] = jj_gen;
2952 if (jj_2_26(2147483647)) {
2953 ECMAForStatement jjtn006 = new ECMAForStatement(this, JJTFORSTATEMENT);
2954 boolean jjtc006 = true;
2955 jjtree.openNodeScope(jjtn006);
2956 jjtreeOpenNodeScope(jjtn006);
2957 try {
2958 jj_consume_token(FOR);
2959 jj_consume_token(LPAREN);
2960 ECMAEmptyExpression jjtn003 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2961 boolean jjtc003 = true;
2962 jjtree.openNodeScope(jjtn003);
2963 jjtreeOpenNodeScope(jjtn003);
2964 try {
2965 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2966 case TYPEOF:
2967 case NEW:
2968 case VOID:
2969 case FUNCTION:
2970 case THIS:
2971 case DELETE:
2972 case LBRACE:
2973 case LPAREN:
2974 case LBRACKET:
2975 case PLUS:
2976 case MINUS:
2977 case INC:
2978 case DEC:
2979 case BNOT:
2980 case NOT:
2981 case NULL_LITERAL:
2982 case BOOLEAN_LITERAL:
2983 case DECIMAL_LITERAL:
2984 case HEX_INTEGER_LITERAL:
2985 case STRING_LITERAL:
2986 case IDENTIFIER_NAME:
2987 case REGULAR_EXPRESSION_LITERAL:
2988 ExpressionNoIn();
2989 break;
2990 default:
2991 jj_la1[63] = jj_gen;
2992 ;
2993 }
2994 } catch (Throwable jjte003) {
2995 if (jjtc003) {
2996 jjtree.clearNodeScope(jjtn003);
2997 jjtc003 = false;
2998 } else {
2999 jjtree.popNode();
3000 }
3001 if (jjte003 instanceof RuntimeException) {
3002 {if (true) throw (RuntimeException)jjte003;}
3003 }
3004 if (jjte003 instanceof ParseException) {
3005 {if (true) throw (ParseException)jjte003;}
3006 }
3007 {if (true) throw (Error)jjte003;}
3008 } finally {
3009 if (jjtc003) {
3010 jjtree.closeNodeScope(jjtn003, jjtree . nodeArity ( ) == 0);
3011 jjtreeCloseNodeScope(jjtn003);
3012 }
3013 }
3014 jj_consume_token(SEMICOLON);
3015 ECMAEmptyExpression jjtn004 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
3016 boolean jjtc004 = true;
3017 jjtree.openNodeScope(jjtn004);
3018 jjtreeOpenNodeScope(jjtn004);
3019 try {
3020 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3021 case TYPEOF:
3022 case NEW:
3023 case VOID:
3024 case FUNCTION:
3025 case THIS:
3026 case DELETE:
3027 case LBRACE:
3028 case LPAREN:
3029 case LBRACKET:
3030 case PLUS:
3031 case MINUS:
3032 case INC:
3033 case DEC:
3034 case BNOT:
3035 case NOT:
3036 case NULL_LITERAL:
3037 case BOOLEAN_LITERAL:
3038 case DECIMAL_LITERAL:
3039 case HEX_INTEGER_LITERAL:
3040 case STRING_LITERAL:
3041 case IDENTIFIER_NAME:
3042 case REGULAR_EXPRESSION_LITERAL:
3043 Expression();
3044 break;
3045 default:
3046 jj_la1[64] = jj_gen;
3047 ;
3048 }
3049 } catch (Throwable jjte004) {
3050 if (jjtc004) {
3051 jjtree.clearNodeScope(jjtn004);
3052 jjtc004 = false;
3053 } else {
3054 jjtree.popNode();
3055 }
3056 if (jjte004 instanceof RuntimeException) {
3057 {if (true) throw (RuntimeException)jjte004;}
3058 }
3059 if (jjte004 instanceof ParseException) {
3060 {if (true) throw (ParseException)jjte004;}
3061 }
3062 {if (true) throw (Error)jjte004;}
3063 } finally {
3064 if (jjtc004) {
3065 jjtree.closeNodeScope(jjtn004, jjtree . nodeArity ( ) == 0);
3066 jjtreeCloseNodeScope(jjtn004);
3067 }
3068 }
3069 jj_consume_token(SEMICOLON);
3070 ECMAEmptyExpression jjtn005 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
3071 boolean jjtc005 = true;
3072 jjtree.openNodeScope(jjtn005);
3073 jjtreeOpenNodeScope(jjtn005);
3074 try {
3075 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3076 case TYPEOF:
3077 case NEW:
3078 case VOID:
3079 case FUNCTION:
3080 case THIS:
3081 case DELETE:
3082 case LBRACE:
3083 case LPAREN:
3084 case LBRACKET:
3085 case PLUS:
3086 case MINUS:
3087 case INC:
3088 case DEC:
3089 case BNOT:
3090 case NOT:
3091 case NULL_LITERAL:
3092 case BOOLEAN_LITERAL:
3093 case DECIMAL_LITERAL:
3094 case HEX_INTEGER_LITERAL:
3095 case STRING_LITERAL:
3096 case IDENTIFIER_NAME:
3097 case REGULAR_EXPRESSION_LITERAL:
3098 Expression();
3099 break;
3100 default:
3101 jj_la1[65] = jj_gen;
3102 ;
3103 }
3104 } catch (Throwable jjte005) {
3105 if (jjtc005) {
3106 jjtree.clearNodeScope(jjtn005);
3107 jjtc005 = false;
3108 } else {
3109 jjtree.popNode();
3110 }
3111 if (jjte005 instanceof RuntimeException) {
3112 {if (true) throw (RuntimeException)jjte005;}
3113 }
3114 if (jjte005 instanceof ParseException) {
3115 {if (true) throw (ParseException)jjte005;}
3116 }
3117 {if (true) throw (Error)jjte005;}
3118 } finally {
3119 if (jjtc005) {
3120 jjtree.closeNodeScope(jjtn005, jjtree . nodeArity ( ) == 0);
3121 jjtreeCloseNodeScope(jjtn005);
3122 }
3123 }
3124 jj_consume_token(RPAREN);
3125 Statement();
3126 } catch (Throwable jjte006) {
3127 if (jjtc006) {
3128 jjtree.clearNodeScope(jjtn006);
3129 jjtc006 = false;
3130 } else {
3131 jjtree.popNode();
3132 }
3133 if (jjte006 instanceof RuntimeException) {
3134 {if (true) throw (RuntimeException)jjte006;}
3135 }
3136 if (jjte006 instanceof ParseException) {
3137 {if (true) throw (ParseException)jjte006;}
3138 }
3139 {if (true) throw (Error)jjte006;}
3140 } finally {
3141 if (jjtc006) {
3142 jjtree.closeNodeScope(jjtn006, true);
3143 jjtreeCloseNodeScope(jjtn006);
3144 }
3145 }
3146 } else if (jj_2_27(2147483647)) {
3147 ECMAForVarStatement jjtn009 = new ECMAForVarStatement(this, JJTFORVARSTATEMENT);
3148 boolean jjtc009 = true;
3149 jjtree.openNodeScope(jjtn009);
3150 jjtreeOpenNodeScope(jjtn009);
3151 try {
3152 jj_consume_token(FOR);
3153 jj_consume_token(LPAREN);
3154 jj_consume_token(VAR);
3155 VariableDeclarationList();
3156 jj_consume_token(SEMICOLON);
3157 ECMAEmptyExpression jjtn007 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
3158 boolean jjtc007 = true;
3159 jjtree.openNodeScope(jjtn007);
3160 jjtreeOpenNodeScope(jjtn007);
3161 try {
3162 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3163 case TYPEOF:
3164 case NEW:
3165 case VOID:
3166 case FUNCTION:
3167 case THIS:
3168 case DELETE:
3169 case LBRACE:
3170 case LPAREN:
3171 case LBRACKET:
3172 case PLUS:
3173 case MINUS:
3174 case INC:
3175 case DEC:
3176 case BNOT:
3177 case NOT:
3178 case NULL_LITERAL:
3179 case BOOLEAN_LITERAL:
3180 case DECIMAL_LITERAL:
3181 case HEX_INTEGER_LITERAL:
3182 case STRING_LITERAL:
3183 case IDENTIFIER_NAME:
3184 case REGULAR_EXPRESSION_LITERAL:
3185 Expression();
3186 break;
3187 default:
3188 jj_la1[66] = jj_gen;
3189 ;
3190 }
3191 } catch (Throwable jjte007) {
3192 if (jjtc007) {
3193 jjtree.clearNodeScope(jjtn007);
3194 jjtc007 = false;
3195 } else {
3196 jjtree.popNode();
3197 }
3198 if (jjte007 instanceof RuntimeException) {
3199 {if (true) throw (RuntimeException)jjte007;}
3200 }
3201 if (jjte007 instanceof ParseException) {
3202 {if (true) throw (ParseException)jjte007;}
3203 }
3204 {if (true) throw (Error)jjte007;}
3205 } finally {
3206 if (jjtc007) {
3207 jjtree.closeNodeScope(jjtn007, jjtree . nodeArity ( ) == 0);
3208 jjtreeCloseNodeScope(jjtn007);
3209 }
3210 }
3211 jj_consume_token(SEMICOLON);
3212 ECMAEmptyExpression jjtn008 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
3213 boolean jjtc008 = true;
3214 jjtree.openNodeScope(jjtn008);
3215 jjtreeOpenNodeScope(jjtn008);
3216 try {
3217 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3218 case TYPEOF:
3219 case NEW:
3220 case VOID:
3221 case FUNCTION:
3222 case THIS:
3223 case DELETE:
3224 case LBRACE:
3225 case LPAREN:
3226 case LBRACKET:
3227 case PLUS:
3228 case MINUS:
3229 case INC:
3230 case DEC:
3231 case BNOT:
3232 case NOT:
3233 case NULL_LITERAL:
3234 case BOOLEAN_LITERAL:
3235 case DECIMAL_LITERAL:
3236 case HEX_INTEGER_LITERAL:
3237 case STRING_LITERAL:
3238 case IDENTIFIER_NAME:
3239 case REGULAR_EXPRESSION_LITERAL:
3240 Expression();
3241 break;
3242 default:
3243 jj_la1[67] = jj_gen;
3244 ;
3245 }
3246 } catch (Throwable jjte008) {
3247 if (jjtc008) {
3248 jjtree.clearNodeScope(jjtn008);
3249 jjtc008 = false;
3250 } else {
3251 jjtree.popNode();
3252 }
3253 if (jjte008 instanceof RuntimeException) {
3254 {if (true) throw (RuntimeException)jjte008;}
3255 }
3256 if (jjte008 instanceof ParseException) {
3257 {if (true) throw (ParseException)jjte008;}
3258 }
3259 {if (true) throw (Error)jjte008;}
3260 } finally {
3261 if (jjtc008) {
3262 jjtree.closeNodeScope(jjtn008, jjtree . nodeArity ( ) == 0);
3263 jjtreeCloseNodeScope(jjtn008);
3264 }
3265 }
3266 jj_consume_token(RPAREN);
3267 Statement();
3268 } catch (Throwable jjte009) {
3269 if (jjtc009) {
3270 jjtree.clearNodeScope(jjtn009);
3271 jjtc009 = false;
3272 } else {
3273 jjtree.popNode();
3274 }
3275 if (jjte009 instanceof RuntimeException) {
3276 {if (true) throw (RuntimeException)jjte009;}
3277 }
3278 if (jjte009 instanceof ParseException) {
3279 {if (true) throw (ParseException)jjte009;}
3280 }
3281 {if (true) throw (Error)jjte009;}
3282 } finally {
3283 if (jjtc009) {
3284 jjtree.closeNodeScope(jjtn009, true);
3285 jjtreeCloseNodeScope(jjtn009);
3286 }
3287 }
3288 } else if (jj_2_28(2147483647)) {
3289 ECMAForVarInStatement jjtn010 = new ECMAForVarInStatement(this, JJTFORVARINSTATEMENT);
3290 boolean jjtc010 = true;
3291 jjtree.openNodeScope(jjtn010);
3292 jjtreeOpenNodeScope(jjtn010);
3293 try {
3294 jj_consume_token(FOR);
3295 jj_consume_token(LPAREN);
3296 jj_consume_token(VAR);
3297 VariableDeclarationNoIn();
3298 jj_consume_token(IN);
3299 Expression();
3300 jj_consume_token(RPAREN);
3301 Statement();
3302 } catch (Throwable jjte010) {
3303 if (jjtc010) {
3304 jjtree.clearNodeScope(jjtn010);
3305 jjtc010 = false;
3306 } else {
3307 jjtree.popNode();
3308 }
3309 if (jjte010 instanceof RuntimeException) {
3310 {if (true) throw (RuntimeException)jjte010;}
3311 }
3312 if (jjte010 instanceof ParseException) {
3313 {if (true) throw (ParseException)jjte010;}
3314 }
3315 {if (true) throw (Error)jjte010;}
3316 } finally {
3317 if (jjtc010) {
3318 jjtree.closeNodeScope(jjtn010, true);
3319 jjtreeCloseNodeScope(jjtn010);
3320 }
3321 }
3322 } else {
3323 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3324 case FOR:
3325 ECMAForInStatement jjtn011 = new ECMAForInStatement(this, JJTFORINSTATEMENT);
3326 boolean jjtc011 = true;
3327 jjtree.openNodeScope(jjtn011);
3328 jjtreeOpenNodeScope(jjtn011);
3329 try {
3330 jj_consume_token(FOR);
3331 jj_consume_token(LPAREN);
3332 LeftHandSideExpression();
3333 jj_consume_token(IN);
3334 Expression();
3335 jj_consume_token(RPAREN);
3336 Statement();
3337 } catch (Throwable jjte011) {
3338 if (jjtc011) {
3339 jjtree.clearNodeScope(jjtn011);
3340 jjtc011 = false;
3341 } else {
3342 jjtree.popNode();
3343 }
3344 if (jjte011 instanceof RuntimeException) {
3345 {if (true) throw (RuntimeException)jjte011;}
3346 }
3347 if (jjte011 instanceof ParseException) {
3348 {if (true) throw (ParseException)jjte011;}
3349 }
3350 {if (true) throw (Error)jjte011;}
3351 } finally {
3352 if (jjtc011) {
3353 jjtree.closeNodeScope(jjtn011, true);
3354 jjtreeCloseNodeScope(jjtn011);
3355 }
3356 }
3357 break;
3358 default:
3359 jj_la1[69] = jj_gen;
3360 jj_consume_token(-1);
3361 throw new ParseException();
3362 }
3363 }
3364 }
3365 }
3366
3367
3368 final public void ContinueStatement() throws ParseException {
3369
3370 ECMAContinueStatement jjtn000 = new ECMAContinueStatement(this, JJTCONTINUESTATEMENT);
3371 boolean jjtc000 = true;
3372 jjtree.openNodeScope(jjtn000);
3373 jjtreeOpenNodeScope(jjtn000);
3374 try {
3375 jj_consume_token(CONTINUE);
3376 if (jj_2_29(2147483647)) {
3377 Identifier();
3378 } else {
3379 ;
3380 }
3381 if (jj_2_30(2147483647)) {
3382 jj_consume_token(SEMICOLON);
3383 } else {
3384 ;
3385 }
3386 } catch (Throwable jjte000) {
3387 if (jjtc000) {
3388 jjtree.clearNodeScope(jjtn000);
3389 jjtc000 = false;
3390 } else {
3391 jjtree.popNode();
3392 }
3393 if (jjte000 instanceof RuntimeException) {
3394 {if (true) throw (RuntimeException)jjte000;}
3395 }
3396 if (jjte000 instanceof ParseException) {
3397 {if (true) throw (ParseException)jjte000;}
3398 }
3399 {if (true) throw (Error)jjte000;}
3400 } finally {
3401 if (jjtc000) {
3402 jjtree.closeNodeScope(jjtn000, true);
3403 jjtreeCloseNodeScope(jjtn000);
3404 }
3405 }
3406 }
3407
3408
3409 final public void BreakStatement() throws ParseException {
3410
3411 ECMABreakStatement jjtn000 = new ECMABreakStatement(this, JJTBREAKSTATEMENT);
3412 boolean jjtc000 = true;
3413 jjtree.openNodeScope(jjtn000);
3414 jjtreeOpenNodeScope(jjtn000);
3415 try {
3416 jj_consume_token(BREAK);
3417 if (jj_2_31(2147483647)) {
3418 Identifier();
3419 } else {
3420 ;
3421 }
3422 if (jj_2_32(2147483647)) {
3423 jj_consume_token(SEMICOLON);
3424 } else {
3425 ;
3426 }
3427 } catch (Throwable jjte000) {
3428 if (jjtc000) {
3429 jjtree.clearNodeScope(jjtn000);
3430 jjtc000 = false;
3431 } else {
3432 jjtree.popNode();
3433 }
3434 if (jjte000 instanceof RuntimeException) {
3435 {if (true) throw (RuntimeException)jjte000;}
3436 }
3437 if (jjte000 instanceof ParseException) {
3438 {if (true) throw (ParseException)jjte000;}
3439 }
3440 {if (true) throw (Error)jjte000;}
3441 } finally {
3442 if (jjtc000) {
3443 jjtree.closeNodeScope(jjtn000, true);
3444 jjtreeCloseNodeScope(jjtn000);
3445 }
3446 }
3447 }
3448
3449
3450 final public void ReturnStatement() throws ParseException {
3451
3452 ECMAReturnStatement jjtn000 = new ECMAReturnStatement(this, JJTRETURNSTATEMENT);
3453 boolean jjtc000 = true;
3454 jjtree.openNodeScope(jjtn000);
3455 jjtreeOpenNodeScope(jjtn000);
3456 try {
3457 jj_consume_token(RETURN);
3458 if (jj_2_33(2147483647)) {
3459 Expression();
3460 } else {
3461 ;
3462 }
3463 if (jj_2_34(2147483647)) {
3464 jj_consume_token(SEMICOLON);
3465 } else {
3466 ;
3467 }
3468 } catch (Throwable jjte000) {
3469 if (jjtc000) {
3470 jjtree.clearNodeScope(jjtn000);
3471 jjtc000 = false;
3472 } else {
3473 jjtree.popNode();
3474 }
3475 if (jjte000 instanceof RuntimeException) {
3476 {if (true) throw (RuntimeException)jjte000;}
3477 }
3478 if (jjte000 instanceof ParseException) {
3479 {if (true) throw (ParseException)jjte000;}
3480 }
3481 {if (true) throw (Error)jjte000;}
3482 } finally {
3483 if (jjtc000) {
3484 jjtree.closeNodeScope(jjtn000, true);
3485 jjtreeCloseNodeScope(jjtn000);
3486 }
3487 }
3488 }
3489
3490
3491 final public void WithStatement() throws ParseException {
3492
3493 ECMAWithStatement jjtn000 = new ECMAWithStatement(this, JJTWITHSTATEMENT);
3494 boolean jjtc000 = true;
3495 jjtree.openNodeScope(jjtn000);
3496 jjtreeOpenNodeScope(jjtn000);
3497 try {
3498 jj_consume_token(WITH);
3499 jj_consume_token(LPAREN);
3500 Expression();
3501 jj_consume_token(RPAREN);
3502 Statement();
3503 } catch (Throwable jjte000) {
3504 if (jjtc000) {
3505 jjtree.clearNodeScope(jjtn000);
3506 jjtc000 = false;
3507 } else {
3508 jjtree.popNode();
3509 }
3510 if (jjte000 instanceof RuntimeException) {
3511 {if (true) throw (RuntimeException)jjte000;}
3512 }
3513 if (jjte000 instanceof ParseException) {
3514 {if (true) throw (ParseException)jjte000;}
3515 }
3516 {if (true) throw (Error)jjte000;}
3517 } finally {
3518 if (jjtc000) {
3519 jjtree.closeNodeScope(jjtn000, true);
3520 jjtreeCloseNodeScope(jjtn000);
3521 }
3522 }
3523 }
3524
3525
3526 final public void SwitchStatement() throws ParseException {
3527
3528 ECMASwitchStatement jjtn000 = new ECMASwitchStatement(this, JJTSWITCHSTATEMENT);
3529 boolean jjtc000 = true;
3530 jjtree.openNodeScope(jjtn000);
3531 jjtreeOpenNodeScope(jjtn000);
3532 try {
3533 jj_consume_token(SWITCH);
3534 jj_consume_token(LPAREN);
3535 Expression();
3536 jj_consume_token(RPAREN);
3537 CaseBlock();
3538 } catch (Throwable jjte000) {
3539 if (jjtc000) {
3540 jjtree.clearNodeScope(jjtn000);
3541 jjtc000 = false;
3542 } else {
3543 jjtree.popNode();
3544 }
3545 if (jjte000 instanceof RuntimeException) {
3546 {if (true) throw (RuntimeException)jjte000;}
3547 }
3548 if (jjte000 instanceof ParseException) {
3549 {if (true) throw (ParseException)jjte000;}
3550 }
3551 {if (true) throw (Error)jjte000;}
3552 } finally {
3553 if (jjtc000) {
3554 jjtree.closeNodeScope(jjtn000, true);
3555 jjtreeCloseNodeScope(jjtn000);
3556 }
3557 }
3558 }
3559
3560 final public void CaseBlock() throws ParseException {
3561
3562 ECMACaseBlock jjtn000 = new ECMACaseBlock(this, JJTCASEBLOCK);
3563 boolean jjtc000 = true;
3564 jjtree.openNodeScope(jjtn000);
3565 jjtreeOpenNodeScope(jjtn000);
3566 try {
3567 jj_consume_token(LBRACE);
3568 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3569 case CASE:
3570 CaseClauses();
3571 break;
3572 default:
3573 jj_la1[70] = jj_gen;
3574 ;
3575 }
3576 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3577 case RBRACE:
3578 jj_consume_token(RBRACE);
3579 break;
3580 case DEFAULT_:
3581 DefaultClause();
3582 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3583 case CASE:
3584 CaseClauses();
3585 break;
3586 default:
3587 jj_la1[71] = jj_gen;
3588 ;
3589 }
3590 jj_consume_token(RBRACE);
3591 break;
3592 default:
3593 jj_la1[72] = jj_gen;
3594 jj_consume_token(-1);
3595 throw new ParseException();
3596 }
3597 } catch (Throwable jjte000) {
3598 if (jjtc000) {
3599 jjtree.clearNodeScope(jjtn000);
3600 jjtc000 = false;
3601 } else {
3602 jjtree.popNode();
3603 }
3604 if (jjte000 instanceof RuntimeException) {
3605 {if (true) throw (RuntimeException)jjte000;}
3606 }
3607 if (jjte000 instanceof ParseException) {
3608 {if (true) throw (ParseException)jjte000;}
3609 }
3610 {if (true) throw (Error)jjte000;}
3611 } finally {
3612 if (jjtc000) {
3613 jjtree.closeNodeScope(jjtn000, true);
3614 jjtreeCloseNodeScope(jjtn000);
3615 }
3616 }
3617 }
3618
3619 final public void CaseClauses() throws ParseException {
3620 label_29:
3621 while (true) {
3622 CaseClause();
3623 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3624 case CASE:
3625 ;
3626 break;
3627 default:
3628 jj_la1[73] = jj_gen;
3629 break label_29;
3630 }
3631 }
3632 }
3633
3634 final public void CaseClause() throws ParseException {
3635
3636 ECMACaseClause jjtn000 = new ECMACaseClause(this, JJTCASECLAUSE);
3637 boolean jjtc000 = true;
3638 jjtree.openNodeScope(jjtn000);
3639 jjtreeOpenNodeScope(jjtn000);
3640 try {
3641 ECMACase jjtn001 = new ECMACase(this, JJTCASE);
3642 boolean jjtc001 = true;
3643 jjtree.openNodeScope(jjtn001);
3644 jjtreeOpenNodeScope(jjtn001);
3645 try {
3646 jj_consume_token(CASE);
3647 Expression();
3648 jj_consume_token(COLON);
3649 } catch (Throwable jjte001) {
3650 if (jjtc001) {
3651 jjtree.clearNodeScope(jjtn001);
3652 jjtc001 = false;
3653 } else {
3654 jjtree.popNode();
3655 }
3656 if (jjte001 instanceof RuntimeException) {
3657 {if (true) throw (RuntimeException)jjte001;}
3658 }
3659 if (jjte001 instanceof ParseException) {
3660 {if (true) throw (ParseException)jjte001;}
3661 }
3662 {if (true) throw (Error)jjte001;}
3663 } finally {
3664 if (jjtc001) {
3665 jjtree.closeNodeScope(jjtn001, true);
3666 jjtreeCloseNodeScope(jjtn001);
3667 }
3668 }
3669 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3670 case BREAK:
3671 case DO:
3672 case TYPEOF:
3673 case NEW:
3674 case VAR:
3675 case RETURN:
3676 case VOID:
3677 case CONTINUE:
3678 case FOR:
3679 case SWITCH:
3680 case WHILE:
3681 case DEBUGGER:
3682 case FUNCTION:
3683 case THIS:
3684 case WITH:
3685 case IF:
3686 case THROW:
3687 case DELETE:
3688 case TRY:
3689 case LBRACE:
3690 case LPAREN:
3691 case LBRACKET:
3692 case SEMICOLON:
3693 case PLUS:
3694 case MINUS:
3695 case INC:
3696 case DEC:
3697 case BNOT:
3698 case NOT:
3699 case NULL_LITERAL:
3700 case BOOLEAN_LITERAL:
3701 case DECIMAL_LITERAL:
3702 case HEX_INTEGER_LITERAL:
3703 case STRING_LITERAL:
3704 case IDENTIFIER_NAME:
3705 case REGULAR_EXPRESSION_LITERAL:
3706 case JAVA_STATEMENT:
3707 StatementList();
3708 break;
3709 default:
3710 jj_la1[74] = jj_gen;
3711 ;
3712 }
3713 } catch (Throwable jjte000) {
3714 if (jjtc000) {
3715 jjtree.clearNodeScope(jjtn000);
3716 jjtc000 = false;
3717 } else {
3718 jjtree.popNode();
3719 }
3720 if (jjte000 instanceof RuntimeException) {
3721 {if (true) throw (RuntimeException)jjte000;}
3722 }
3723 if (jjte000 instanceof ParseException) {
3724 {if (true) throw (ParseException)jjte000;}
3725 }
3726 {if (true) throw (Error)jjte000;}
3727 } finally {
3728 if (jjtc000) {
3729 jjtree.closeNodeScope(jjtn000, true);
3730 jjtreeCloseNodeScope(jjtn000);
3731 }
3732 }
3733 }
3734
3735 final public void DefaultClause() throws ParseException {
3736
3737 ECMACaseClause jjtn000 = new ECMACaseClause(this, JJTCASECLAUSE);
3738 boolean jjtc000 = true;
3739 jjtree.openNodeScope(jjtn000);
3740 jjtreeOpenNodeScope(jjtn000);
3741 try {
3742 ECMACase jjtn001 = new ECMACase(this, JJTCASE);
3743 boolean jjtc001 = true;
3744 jjtree.openNodeScope(jjtn001);
3745 jjtreeOpenNodeScope(jjtn001);
3746 try {
3747 jj_consume_token(DEFAULT_);
3748 jj_consume_token(COLON);
3749 } finally {
3750 if (jjtc001) {
3751 jjtree.closeNodeScope(jjtn001, true);
3752 jjtreeCloseNodeScope(jjtn001);
3753 }
3754 }
3755 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3756 case BREAK:
3757 case DO:
3758 case TYPEOF:
3759 case NEW:
3760 case VAR:
3761 case RETURN:
3762 case VOID:
3763 case CONTINUE:
3764 case FOR:
3765 case SWITCH:
3766 case WHILE:
3767 case DEBUGGER:
3768 case FUNCTION:
3769 case THIS:
3770 case WITH:
3771 case IF:
3772 case THROW:
3773 case DELETE:
3774 case TRY:
3775 case LBRACE:
3776 case LPAREN:
3777 case LBRACKET:
3778 case SEMICOLON:
3779 case PLUS:
3780 case MINUS:
3781 case INC:
3782 case DEC:
3783 case BNOT:
3784 case NOT:
3785 case NULL_LITERAL:
3786 case BOOLEAN_LITERAL:
3787 case DECIMAL_LITERAL:
3788 case HEX_INTEGER_LITERAL:
3789 case STRING_LITERAL:
3790 case IDENTIFIER_NAME:
3791 case REGULAR_EXPRESSION_LITERAL:
3792 case JAVA_STATEMENT:
3793 StatementList();
3794 break;
3795 default:
3796 jj_la1[75] = jj_gen;
3797 ;
3798 }
3799 } catch (Throwable jjte000) {
3800 if (jjtc000) {
3801 jjtree.clearNodeScope(jjtn000);
3802 jjtc000 = false;
3803 } else {
3804 jjtree.popNode();
3805 }
3806 if (jjte000 instanceof RuntimeException) {
3807 {if (true) throw (RuntimeException)jjte000;}
3808 }
3809 if (jjte000 instanceof ParseException) {
3810 {if (true) throw (ParseException)jjte000;}
3811 }
3812 {if (true) throw (Error)jjte000;}
3813 } finally {
3814 if (jjtc000) {
3815 jjtree.closeNodeScope(jjtn000, true);
3816 jjtreeCloseNodeScope(jjtn000);
3817 }
3818 }
3819 }
3820
3821
3822 final public void LabelledStatement() throws ParseException {
3823
3824 ECMALabelledStatement jjtn000 = new ECMALabelledStatement(this, JJTLABELLEDSTATEMENT);
3825 boolean jjtc000 = true;
3826 jjtree.openNodeScope(jjtn000);
3827 jjtreeOpenNodeScope(jjtn000);
3828 try {
3829 Identifier();
3830 jj_consume_token(COLON);
3831 Statement();
3832 } catch (Throwable jjte000) {
3833 if (jjtc000) {
3834 jjtree.clearNodeScope(jjtn000);
3835 jjtc000 = false;
3836 } else {
3837 jjtree.popNode();
3838 }
3839 if (jjte000 instanceof RuntimeException) {
3840 {if (true) throw (RuntimeException)jjte000;}
3841 }
3842 if (jjte000 instanceof ParseException) {
3843 {if (true) throw (ParseException)jjte000;}
3844 }
3845 {if (true) throw (Error)jjte000;}
3846 } finally {
3847 if (jjtc000) {
3848 jjtree.closeNodeScope(jjtn000, true);
3849 jjtreeCloseNodeScope(jjtn000);
3850 }
3851 }
3852 }
3853
3854 final public void ThrowStatement() throws ParseException {
3855
3856 ECMAThrowStatement jjtn000 = new ECMAThrowStatement(this, JJTTHROWSTATEMENT);
3857 boolean jjtc000 = true;
3858 jjtree.openNodeScope(jjtn000);
3859 jjtreeOpenNodeScope(jjtn000);
3860 try {
3861 jj_consume_token(THROW);
3862 Expression();
3863 if (jj_2_35(2147483647)) {
3864 jj_consume_token(SEMICOLON);
3865 } else {
3866 ;
3867 }
3868 } catch (Throwable jjte000) {
3869 if (jjtc000) {
3870 jjtree.clearNodeScope(jjtn000);
3871 jjtc000 = false;
3872 } else {
3873 jjtree.popNode();
3874 }
3875 if (jjte000 instanceof RuntimeException) {
3876 {if (true) throw (RuntimeException)jjte000;}
3877 }
3878 if (jjte000 instanceof ParseException) {
3879 {if (true) throw (ParseException)jjte000;}
3880 }
3881 {if (true) throw (Error)jjte000;}
3882 } finally {
3883 if (jjtc000) {
3884 jjtree.closeNodeScope(jjtn000, true);
3885 jjtreeCloseNodeScope(jjtn000);
3886 }
3887 }
3888 }
3889
3890 final public void TryStatement() throws ParseException {
3891
3892 ECMATryStatement jjtn000 = new ECMATryStatement(this, JJTTRYSTATEMENT);
3893 boolean jjtc000 = true;
3894 jjtree.openNodeScope(jjtn000);
3895 jjtreeOpenNodeScope(jjtn000);
3896 try {
3897 jj_consume_token(TRY);
3898 Block();
3899 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3900 case FINALLY:
3901 Finally();
3902 break;
3903 case CATCH:
3904 Catch();
3905 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3906 case FINALLY:
3907 Finally();
3908 break;
3909 default:
3910 jj_la1[76] = jj_gen;
3911 ;
3912 }
3913 break;
3914 default:
3915 jj_la1[77] = jj_gen;
3916 jj_consume_token(-1);
3917 throw new ParseException();
3918 }
3919 } catch (Throwable jjte000) {
3920 if (jjtc000) {
3921 jjtree.clearNodeScope(jjtn000);
3922 jjtc000 = false;
3923 } else {
3924 jjtree.popNode();
3925 }
3926 if (jjte000 instanceof RuntimeException) {
3927 {if (true) throw (RuntimeException)jjte000;}
3928 }
3929 if (jjte000 instanceof ParseException) {
3930 {if (true) throw (ParseException)jjte000;}
3931 }
3932 {if (true) throw (Error)jjte000;}
3933 } finally {
3934 if (jjtc000) {
3935 jjtree.closeNodeScope(jjtn000, true);
3936 jjtreeCloseNodeScope(jjtn000);
3937 }
3938 }
3939 }
3940
3941 final public void Catch() throws ParseException {
3942
3943 ECMACatch jjtn000 = new ECMACatch(this, JJTCATCH);
3944 boolean jjtc000 = true;
3945 jjtree.openNodeScope(jjtn000);
3946 jjtreeOpenNodeScope(jjtn000);
3947 try {
3948 jj_consume_token(CATCH);
3949 jj_consume_token(LPAREN);
3950 Identifier();
3951 jj_consume_token(RPAREN);
3952 Block();
3953 } catch (Throwable jjte000) {
3954 if (jjtc000) {
3955 jjtree.clearNodeScope(jjtn000);
3956 jjtc000 = false;
3957 } else {
3958 jjtree.popNode();
3959 }
3960 if (jjte000 instanceof RuntimeException) {
3961 {if (true) throw (RuntimeException)jjte000;}
3962 }
3963 if (jjte000 instanceof ParseException) {
3964 {if (true) throw (ParseException)jjte000;}
3965 }
3966 {if (true) throw (Error)jjte000;}
3967 } finally {
3968 if (jjtc000) {
3969 jjtree.closeNodeScope(jjtn000, true);
3970 jjtreeCloseNodeScope(jjtn000);
3971 }
3972 }
3973 }
3974
3975 final public void Finally() throws ParseException {
3976
3977 ECMAFinally jjtn000 = new ECMAFinally(this, JJTFINALLY);
3978 boolean jjtc000 = true;
3979 jjtree.openNodeScope(jjtn000);
3980 jjtreeOpenNodeScope(jjtn000);
3981 try {
3982 jj_consume_token(FINALLY);
3983 Block();
3984 } catch (Throwable jjte000) {
3985 if (jjtc000) {
3986 jjtree.clearNodeScope(jjtn000);
3987 jjtc000 = false;
3988 } else {
3989 jjtree.popNode();
3990 }
3991 if (jjte000 instanceof RuntimeException) {
3992 {if (true) throw (RuntimeException)jjte000;}
3993 }
3994 if (jjte000 instanceof ParseException) {
3995 {if (true) throw (ParseException)jjte000;}
3996 }
3997 {if (true) throw (Error)jjte000;}
3998 } finally {
3999 if (jjtc000) {
4000 jjtree.closeNodeScope(jjtn000, true);
4001 jjtreeCloseNodeScope(jjtn000);
4002 }
4003 }
4004 }
4005
4006
4007 final public void DebuggerStatement() throws ParseException {
4008
4009 ECMADebuggerStatement jjtn000 = new ECMADebuggerStatement(this, JJTDEBUGGERSTATEMENT);
4010 boolean jjtc000 = true;
4011 jjtree.openNodeScope(jjtn000);
4012 jjtreeOpenNodeScope(jjtn000);
4013 try {
4014 jj_consume_token(DEBUGGER);
4015 if (jj_2_36(2147483647)) {
4016 jj_consume_token(SEMICOLON);
4017 } else {
4018 ;
4019 }
4020 } finally {
4021 if (jjtc000) {
4022 jjtree.closeNodeScope(jjtn000, true);
4023 jjtreeCloseNodeScope(jjtn000);
4024 }
4025 }
4026 }
4027
4028
4029 final public void FunctionDeclaration() throws ParseException {
4030
4031 ECMAFunctionDeclaration jjtn000 = new ECMAFunctionDeclaration(this, JJTFUNCTIONDECLARATION);
4032 boolean jjtc000 = true;
4033 jjtree.openNodeScope(jjtn000);
4034 jjtreeOpenNodeScope(jjtn000);
4035 try {
4036 jj_consume_token(FUNCTION);
4037 Identifier();
4038 ECMAFormalParameterList jjtn001 = new ECMAFormalParameterList(this, JJTFORMALPARAMETERLIST);
4039 boolean jjtc001 = true;
4040 jjtree.openNodeScope(jjtn001);
4041 jjtreeOpenNodeScope(jjtn001);
4042 try {
4043 jj_consume_token(LPAREN);
4044 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4045 case IDENTIFIER_NAME:
4046 FormalParameterList();
4047 break;
4048 default:
4049 jj_la1[78] = jj_gen;
4050 ;
4051 }
4052 jj_consume_token(RPAREN);
4053 } catch (Throwable jjte001) {
4054 if (jjtc001) {
4055 jjtree.clearNodeScope(jjtn001);
4056 jjtc001 = false;
4057 } else {
4058 jjtree.popNode();
4059 }
4060 if (jjte001 instanceof RuntimeException) {
4061 {if (true) throw (RuntimeException)jjte001;}
4062 }
4063 if (jjte001 instanceof ParseException) {
4064 {if (true) throw (ParseException)jjte001;}
4065 }
4066 {if (true) throw (Error)jjte001;}
4067 } finally {
4068 if (jjtc001) {
4069 jjtree.closeNodeScope(jjtn001, true);
4070 jjtreeCloseNodeScope(jjtn001);
4071 }
4072 }
4073 FunctionBody();
4074 } catch (Throwable jjte000) {
4075 if (jjtc000) {
4076 jjtree.clearNodeScope(jjtn000);
4077 jjtc000 = false;
4078 } else {
4079 jjtree.popNode();
4080 }
4081 if (jjte000 instanceof RuntimeException) {
4082 {if (true) throw (RuntimeException)jjte000;}
4083 }
4084 if (jjte000 instanceof ParseException) {
4085 {if (true) throw (ParseException)jjte000;}
4086 }
4087 {if (true) throw (Error)jjte000;}
4088 } finally {
4089 if (jjtc000) {
4090 jjtree.closeNodeScope(jjtn000, true);
4091 jjtreeCloseNodeScope(jjtn000);
4092 }
4093 }
4094 }
4095
4096 final public void FunctionExpression() throws ParseException {
4097
4098 ECMAFunctionExpression jjtn000 = new ECMAFunctionExpression(this, JJTFUNCTIONEXPRESSION);
4099 boolean jjtc000 = true;
4100 jjtree.openNodeScope(jjtn000);
4101 jjtreeOpenNodeScope(jjtn000);
4102 try {
4103 jj_consume_token(FUNCTION);
4104 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4105 case IDENTIFIER_NAME:
4106 Identifier();
4107 break;
4108 default:
4109 jj_la1[79] = jj_gen;
4110 ;
4111 }
4112 ECMAFormalParameterList jjtn001 = new ECMAFormalParameterList(this, JJTFORMALPARAMETERLIST);
4113 boolean jjtc001 = true;
4114 jjtree.openNodeScope(jjtn001);
4115 jjtreeOpenNodeScope(jjtn001);
4116 try {
4117 jj_consume_token(LPAREN);
4118 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4119 case IDENTIFIER_NAME:
4120 FormalParameterList();
4121 break;
4122 default:
4123 jj_la1[80] = jj_gen;
4124 ;
4125 }
4126 jj_consume_token(RPAREN);
4127 } catch (Throwable jjte001) {
4128 if (jjtc001) {
4129 jjtree.clearNodeScope(jjtn001);
4130 jjtc001 = false;
4131 } else {
4132 jjtree.popNode();
4133 }
4134 if (jjte001 instanceof RuntimeException) {
4135 {if (true) throw (RuntimeException)jjte001;}
4136 }
4137 if (jjte001 instanceof ParseException) {
4138 {if (true) throw (ParseException)jjte001;}
4139 }
4140 {if (true) throw (Error)jjte001;}
4141 } finally {
4142 if (jjtc001) {
4143 jjtree.closeNodeScope(jjtn001, true);
4144 jjtreeCloseNodeScope(jjtn001);
4145 }
4146 }
4147 FunctionBody();
4148 } catch (Throwable jjte000) {
4149 if (jjtc000) {
4150 jjtree.clearNodeScope(jjtn000);
4151 jjtc000 = false;
4152 } else {
4153 jjtree.popNode();
4154 }
4155 if (jjte000 instanceof RuntimeException) {
4156 {if (true) throw (RuntimeException)jjte000;}
4157 }
4158 if (jjte000 instanceof ParseException) {
4159 {if (true) throw (ParseException)jjte000;}
4160 }
4161 {if (true) throw (Error)jjte000;}
4162 } finally {
4163 if (jjtc000) {
4164 jjtree.closeNodeScope(jjtn000, true);
4165 jjtreeCloseNodeScope(jjtn000);
4166 }
4167 }
4168 }
4169
4170 final public void FormalParameterList() throws ParseException {
4171 Identifier();
4172 label_30:
4173 while (true) {
4174 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4175 case COMMA:
4176 ;
4177 break;
4178 default:
4179 jj_la1[81] = jj_gen;
4180 break label_30;
4181 }
4182 jj_consume_token(COMMA);
4183 Identifier();
4184 }
4185 }
4186
4187 final public void FunctionBody() throws ParseException {
4188
4189 ECMABlock jjtn000 = new ECMABlock(this, JJTBLOCK);
4190 boolean jjtc000 = true;
4191 jjtree.openNodeScope(jjtn000);
4192 jjtreeOpenNodeScope(jjtn000);
4193 try {
4194 jj_consume_token(LBRACE);
4195 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4196 case BREAK:
4197 case DO:
4198 case TYPEOF:
4199 case NEW:
4200 case VAR:
4201 case RETURN:
4202 case VOID:
4203 case CONTINUE:
4204 case FOR:
4205 case SWITCH:
4206 case WHILE:
4207 case DEBUGGER:
4208 case FUNCTION:
4209 case THIS:
4210 case WITH:
4211 case IF:
4212 case THROW:
4213 case DELETE:
4214 case TRY:
4215 case LBRACE:
4216 case LPAREN:
4217 case LBRACKET:
4218 case SEMICOLON:
4219 case PLUS:
4220 case MINUS:
4221 case INC:
4222 case DEC:
4223 case BNOT:
4224 case NOT:
4225 case NULL_LITERAL:
4226 case BOOLEAN_LITERAL:
4227 case DECIMAL_LITERAL:
4228 case HEX_INTEGER_LITERAL:
4229 case STRING_LITERAL:
4230 case IDENTIFIER_NAME:
4231 case REGULAR_EXPRESSION_LITERAL:
4232 case JAVA_STATEMENT:
4233 SourceElements();
4234 break;
4235 default:
4236 jj_la1[82] = jj_gen;
4237 ;
4238 }
4239 jj_consume_token(RBRACE);
4240 } catch (Throwable jjte000) {
4241 if (jjtc000) {
4242 jjtree.clearNodeScope(jjtn000);
4243 jjtc000 = false;
4244 } else {
4245 jjtree.popNode();
4246 }
4247 if (jjte000 instanceof RuntimeException) {
4248 {if (true) throw (RuntimeException)jjte000;}
4249 }
4250 if (jjte000 instanceof ParseException) {
4251 {if (true) throw (ParseException)jjte000;}
4252 }
4253 {if (true) throw (Error)jjte000;}
4254 } finally {
4255 if (jjtc000) {
4256 jjtree.closeNodeScope(jjtn000, true);
4257 jjtreeCloseNodeScope(jjtn000);
4258 }
4259 }
4260 }
4261
4262
4263 final public ECMAProgram Program() throws ParseException {
4264
4265 ECMAProgram jjtn000 = new ECMAProgram(this, JJTPROGRAM);
4266 boolean jjtc000 = true;
4267 jjtree.openNodeScope(jjtn000);
4268 jjtreeOpenNodeScope(jjtn000);
4269 try {
4270 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4271 case BREAK:
4272 case DO:
4273 case TYPEOF:
4274 case NEW:
4275 case VAR:
4276 case RETURN:
4277 case VOID:
4278 case CONTINUE:
4279 case FOR:
4280 case SWITCH:
4281 case WHILE:
4282 case DEBUGGER:
4283 case FUNCTION:
4284 case THIS:
4285 case WITH:
4286 case IF:
4287 case THROW:
4288 case DELETE:
4289 case TRY:
4290 case LBRACE:
4291 case LPAREN:
4292 case LBRACKET:
4293 case SEMICOLON:
4294 case PLUS:
4295 case MINUS:
4296 case INC:
4297 case DEC:
4298 case BNOT:
4299 case NOT:
4300 case NULL_LITERAL:
4301 case BOOLEAN_LITERAL:
4302 case DECIMAL_LITERAL:
4303 case HEX_INTEGER_LITERAL:
4304 case STRING_LITERAL:
4305 case IDENTIFIER_NAME:
4306 case REGULAR_EXPRESSION_LITERAL:
4307 case JAVA_STATEMENT:
4308 SourceElements();
4309 break;
4310 default:
4311 jj_la1[83] = jj_gen;
4312 ;
4313 }
4314 jj_consume_token(0);
4315 jjtree.closeNodeScope(jjtn000, true);
4316 jjtc000 = false;
4317 jjtreeCloseNodeScope(jjtn000);
4318 {if (true) return jjtn000;}
4319 } catch (Throwable jjte000) {
4320 if (jjtc000) {
4321 jjtree.clearNodeScope(jjtn000);
4322 jjtc000 = false;
4323 } else {
4324 jjtree.popNode();
4325 }
4326 if (jjte000 instanceof RuntimeException) {
4327 {if (true) throw (RuntimeException)jjte000;}
4328 }
4329 if (jjte000 instanceof ParseException) {
4330 {if (true) throw (ParseException)jjte000;}
4331 }
4332 {if (true) throw (Error)jjte000;}
4333 } finally {
4334 if (jjtc000) {
4335 jjtree.closeNodeScope(jjtn000, true);
4336 jjtreeCloseNodeScope(jjtn000);
4337 }
4338 }
4339 throw new Error("Missing return statement in function");
4340 }
4341
4342 final public void SourceElements() throws ParseException {
4343 label_31:
4344 while (true) {
4345 SourceElement();
4346 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4347 case BREAK:
4348 case DO:
4349 case TYPEOF:
4350 case NEW:
4351 case VAR:
4352 case RETURN:
4353 case VOID:
4354 case CONTINUE:
4355 case FOR:
4356 case SWITCH:
4357 case WHILE:
4358 case DEBUGGER:
4359 case FUNCTION:
4360 case THIS:
4361 case WITH:
4362 case IF:
4363 case THROW:
4364 case DELETE:
4365 case TRY:
4366 case LBRACE:
4367 case LPAREN:
4368 case LBRACKET:
4369 case SEMICOLON:
4370 case PLUS:
4371 case MINUS:
4372 case INC:
4373 case DEC:
4374 case BNOT:
4375 case NOT:
4376 case NULL_LITERAL:
4377 case BOOLEAN_LITERAL:
4378 case DECIMAL_LITERAL:
4379 case HEX_INTEGER_LITERAL:
4380 case STRING_LITERAL:
4381 case IDENTIFIER_NAME:
4382 case REGULAR_EXPRESSION_LITERAL:
4383 case JAVA_STATEMENT:
4384 ;
4385 break;
4386 default:
4387 jj_la1[84] = jj_gen;
4388 break label_31;
4389 }
4390 }
4391 }
4392
4393 final public void SourceElement() throws ParseException {
4394 if (jj_2_37(2147483647)) {
4395 FunctionDeclaration();
4396 } else {
4397 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4398 case BREAK:
4399 case DO:
4400 case TYPEOF:
4401 case NEW:
4402 case VAR:
4403 case RETURN:
4404 case VOID:
4405 case CONTINUE:
4406 case FOR:
4407 case SWITCH:
4408 case WHILE:
4409 case DEBUGGER:
4410 case FUNCTION:
4411 case THIS:
4412 case WITH:
4413 case IF:
4414 case THROW:
4415 case DELETE:
4416 case TRY:
4417 case LBRACE:
4418 case LPAREN:
4419 case LBRACKET:
4420 case SEMICOLON:
4421 case PLUS:
4422 case MINUS:
4423 case INC:
4424 case DEC:
4425 case BNOT:
4426 case NOT:
4427 case NULL_LITERAL:
4428 case BOOLEAN_LITERAL:
4429 case DECIMAL_LITERAL:
4430 case HEX_INTEGER_LITERAL:
4431 case STRING_LITERAL:
4432 case IDENTIFIER_NAME:
4433 case REGULAR_EXPRESSION_LITERAL:
4434 case JAVA_STATEMENT:
4435 Statement();
4436 break;
4437 default:
4438 jj_la1[85] = jj_gen;
4439 jj_consume_token(-1);
4440 throw new ParseException();
4441 }
4442 }
4443 }
4444
4445
4446 final public void Identifier() throws ParseException {
4447
4448 ECMAIdentifier jjtn000 = new ECMAIdentifier(this, JJTIDENTIFIER);
4449 boolean jjtc000 = true;
4450 jjtree.openNodeScope(jjtn000);
4451 jjtreeOpenNodeScope(jjtn000);Token t;
4452 try {
4453 t = jj_consume_token(IDENTIFIER_NAME);
4454 jjtree.closeNodeScope(jjtn000, true);
4455 jjtc000 = false;
4456 jjtreeCloseNodeScope(jjtn000);
4457 jjtn000.jjtSetValue(t.image);
4458 } finally {
4459 if (jjtc000) {
4460 jjtree.closeNodeScope(jjtn000, true);
4461 jjtreeCloseNodeScope(jjtn000);
4462 }
4463 }
4464 }
4465
4466 private boolean jj_2_1(int xla) {
4467 jj_la = xla; jj_lastpos = jj_scanpos = token;
4468 try { return !jj_3_1(); }
4469 catch(LookaheadSuccess ls) { return true; }
4470 finally { jj_save(0, xla); }
4471 }
4472
4473 private boolean jj_2_2(int xla) {
4474 jj_la = xla; jj_lastpos = jj_scanpos = token;
4475 try { return !jj_3_2(); }
4476 catch(LookaheadSuccess ls) { return true; }
4477 finally { jj_save(1, xla); }
4478 }
4479
4480 private boolean jj_2_3(int xla) {
4481 jj_la = xla; jj_lastpos = jj_scanpos = token;
4482 try { return !jj_3_3(); }
4483 catch(LookaheadSuccess ls) { return true; }
4484 finally { jj_save(2, xla); }
4485 }
4486
4487 private boolean jj_2_4(int xla) {
4488 jj_la = xla; jj_lastpos = jj_scanpos = token;
4489 try { return !jj_3_4(); }
4490 catch(LookaheadSuccess ls) { return true; }
4491 finally { jj_save(3, xla); }
4492 }
4493
4494 private boolean jj_2_5(int xla) {
4495 jj_la = xla; jj_lastpos = jj_scanpos = token;
4496 try { return !jj_3_5(); }
4497 catch(LookaheadSuccess ls) { return true; }
4498 finally { jj_save(4, xla); }
4499 }
4500
4501 private boolean jj_2_6(int xla) {
4502 jj_la = xla; jj_lastpos = jj_scanpos = token;
4503 try { return !jj_3_6(); }
4504 catch(LookaheadSuccess ls) { return true; }
4505 finally { jj_save(5, xla); }
4506 }
4507
4508 private boolean jj_2_7(int xla) {
4509 jj_la = xla; jj_lastpos = jj_scanpos = token;
4510 try { return !jj_3_7(); }
4511 catch(LookaheadSuccess ls) { return true; }
4512 finally { jj_save(6, xla); }
4513 }
4514
4515 private boolean jj_2_8(int xla) {
4516 jj_la = xla; jj_lastpos = jj_scanpos = token;
4517 try { return !jj_3_8(); }
4518 catch(LookaheadSuccess ls) { return true; }
4519 finally { jj_save(7, xla); }
4520 }
4521
4522 private boolean jj_2_9(int xla) {
4523 jj_la = xla; jj_lastpos = jj_scanpos = token;
4524 try { return !jj_3_9(); }
4525 catch(LookaheadSuccess ls) { return true; }
4526 finally { jj_save(8, xla); }
4527 }
4528
4529 private boolean jj_2_10(int xla) {
4530 jj_la = xla; jj_lastpos = jj_scanpos = token;
4531 try { return !jj_3_10(); }
4532 catch(LookaheadSuccess ls) { return true; }
4533 finally { jj_save(9, xla); }
4534 }
4535
4536 private boolean jj_2_11(int xla) {
4537 jj_la = xla; jj_lastpos = jj_scanpos = token;
4538 try { return !jj_3_11(); }
4539 catch(LookaheadSuccess ls) { return true; }
4540 finally { jj_save(10, xla); }
4541 }
4542
4543 private boolean jj_2_12(int xla) {
4544 jj_la = xla; jj_lastpos = jj_scanpos = token;
4545 try { return !jj_3_12(); }
4546 catch(LookaheadSuccess ls) { return true; }
4547 finally { jj_save(11, xla); }
4548 }
4549
4550 private boolean jj_2_13(int xla) {
4551 jj_la = xla; jj_lastpos = jj_scanpos = token;
4552 try { return !jj_3_13(); }
4553 catch(LookaheadSuccess ls) { return true; }
4554 finally { jj_save(12, xla); }
4555 }
4556
4557 private boolean jj_2_14(int xla) {
4558 jj_la = xla; jj_lastpos = jj_scanpos = token;
4559 try { return !jj_3_14(); }
4560 catch(LookaheadSuccess ls) { return true; }
4561 finally { jj_save(13, xla); }
4562 }
4563
4564 private boolean jj_2_15(int xla) {
4565 jj_la = xla; jj_lastpos = jj_scanpos = token;
4566 try { return !jj_3_15(); }
4567 catch(LookaheadSuccess ls) { return true; }
4568 finally { jj_save(14, xla); }
4569 }
4570
4571 private boolean jj_2_16(int xla) {
4572 jj_la = xla; jj_lastpos = jj_scanpos = token;
4573 try { return !jj_3_16(); }
4574 catch(LookaheadSuccess ls) { return true; }
4575 finally { jj_save(15, xla); }
4576 }
4577
4578 private boolean jj_2_17(int xla) {
4579 jj_la = xla; jj_lastpos = jj_scanpos = token;
4580 try { return !jj_3_17(); }
4581 catch(LookaheadSuccess ls) { return true; }
4582 finally { jj_save(16, xla); }
4583 }
4584
4585 private boolean jj_2_18(int xla) {
4586 jj_la = xla; jj_lastpos = jj_scanpos = token;
4587 try { return !jj_3_18(); }
4588 catch(LookaheadSuccess ls) { return true; }
4589 finally { jj_save(17, xla); }
4590 }
4591
4592 private boolean jj_2_19(int xla) {
4593 jj_la = xla; jj_lastpos = jj_scanpos = token;
4594 try { return !jj_3_19(); }
4595 catch(LookaheadSuccess ls) { return true; }
4596 finally { jj_save(18, xla); }
4597 }
4598
4599 private boolean jj_2_20(int xla) {
4600 jj_la = xla; jj_lastpos = jj_scanpos = token