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