001 /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */ 002 package org.apache.commons.jexl2.parser; 003 004 import java.io.Reader; 005 import org.apache.commons.jexl2.JexlInfo; 006 007 public class Parser extends StringParser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/ 008 protected JJTParserState jjtree = new JJTParserState();public boolean ALLOW_REGISTERS = false; 009 010 public ASTJexlScript parse(Reader reader, JexlInfo info) 011 throws ParseException { 012 /* 013 * If registers are allowed, the default parser state has to be REGISTERS. 014 */ 015 if (ALLOW_REGISTERS) { 016 token_source.defaultLexState = REGISTERS; 017 } 018 ReInit(reader); 019 /* 020 * lets do the 'Unique Init' in here to be 021 * safe - it's a pain to remember 022 */ 023 024 ASTJexlScript tree = JexlScript(); 025 tree.value = info; 026 return tree; 027 } 028 029 void jjtreeOpenNodeScope(Node n) {} 030 void jjtreeCloseNodeScope(Node n) throws ParseException { 031 if (n instanceof ASTAmbiguous && n.jjtGetNumChildren() > 0) { 032 Token tok = this.getToken(0); 033 StringBuilder strb = new StringBuilder("Ambiguous statement "); 034 if (tok != null) { 035 strb.append("@"); 036 strb.append(tok.beginLine); 037 strb.append(":"); 038 strb.append(tok.beginColumn); 039 } 040 strb.append(", missing ';' between expressions"); 041 throw new ParseException(strb.toString()); 042 } 043 } 044 045 /*************************************** 046 * Statements 047 ***************************************/ 048 final public ASTJexlScript JexlScript() throws ParseException { 049 /*@bgen(jjtree) JexlScript */ 050 ASTJexlScript jjtn000 = new ASTJexlScript(JJTJEXLSCRIPT); 051 boolean jjtc000 = true; 052 jjtree.openNodeScope(jjtn000); 053 jjtreeOpenNodeScope(jjtn000); 054 try { 055 label_1: 056 while (true) { 057 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 058 case IF: 059 case FOR: 060 case FOREACH: 061 case WHILE: 062 case NEW: 063 case EMPTY: 064 case SIZE: 065 case NULL: 066 case TRUE: 067 case FALSE: 068 case LPAREN: 069 case LCURLY: 070 case LBRACKET: 071 case SEMICOL: 072 case not: 073 case minus: 074 case tilda: 075 case IDENTIFIER: 076 case REGISTER: 077 case INTEGER_LITERAL: 078 case FLOAT_LITERAL: 079 case STRING_LITERAL: 080 ; 081 break; 082 default: 083 jj_la1[0] = jj_gen; 084 break label_1; 085 } 086 Statement(); 087 } 088 jj_consume_token(0); 089 jjtree.closeNodeScope(jjtn000, true); 090 jjtc000 = false; 091 jjtreeCloseNodeScope(jjtn000); 092 {if (true) return jjtn000;} 093 } catch (Throwable jjte000) { 094 if (jjtc000) { 095 jjtree.clearNodeScope(jjtn000); 096 jjtc000 = false; 097 } else { 098 jjtree.popNode(); 099 } 100 if (jjte000 instanceof RuntimeException) { 101 {if (true) throw (RuntimeException)jjte000;} 102 } 103 if (jjte000 instanceof ParseException) { 104 {if (true) throw (ParseException)jjte000;} 105 } 106 {if (true) throw (Error)jjte000;} 107 } finally { 108 if (jjtc000) { 109 jjtree.closeNodeScope(jjtn000, true); 110 jjtreeCloseNodeScope(jjtn000); 111 } 112 } 113 throw new Error("Missing return statement in function"); 114 } 115 116 final public void Statement() throws ParseException { 117 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 118 case SEMICOL: 119 jj_consume_token(SEMICOL); 120 break; 121 default: 122 jj_la1[1] = jj_gen; 123 if (jj_2_1(3)) { 124 Block(); 125 } else { 126 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 127 case IF: 128 IfStatement(); 129 break; 130 case FOR: 131 case FOREACH: 132 ForeachStatement(); 133 break; 134 case WHILE: 135 WhileStatement(); 136 break; 137 case NEW: 138 case EMPTY: 139 case SIZE: 140 case NULL: 141 case TRUE: 142 case FALSE: 143 case LPAREN: 144 case LCURLY: 145 case LBRACKET: 146 case not: 147 case minus: 148 case tilda: 149 case IDENTIFIER: 150 case REGISTER: 151 case INTEGER_LITERAL: 152 case FLOAT_LITERAL: 153 case STRING_LITERAL: 154 ExpressionStatement(); 155 break; 156 default: 157 jj_la1[2] = jj_gen; 158 jj_consume_token(-1); 159 throw new ParseException(); 160 } 161 } 162 } 163 } 164 165 final public void Block() throws ParseException { 166 /*@bgen(jjtree) Block */ 167 ASTBlock jjtn000 = new ASTBlock(JJTBLOCK); 168 boolean jjtc000 = true; 169 jjtree.openNodeScope(jjtn000); 170 jjtreeOpenNodeScope(jjtn000); 171 try { 172 jj_consume_token(LCURLY); 173 label_2: 174 while (true) { 175 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 176 case IF: 177 case FOR: 178 case FOREACH: 179 case WHILE: 180 case NEW: 181 case EMPTY: 182 case SIZE: 183 case NULL: 184 case TRUE: 185 case FALSE: 186 case LPAREN: 187 case LCURLY: 188 case LBRACKET: 189 case SEMICOL: 190 case not: 191 case minus: 192 case tilda: 193 case IDENTIFIER: 194 case REGISTER: 195 case INTEGER_LITERAL: 196 case FLOAT_LITERAL: 197 case STRING_LITERAL: 198 ; 199 break; 200 default: 201 jj_la1[3] = jj_gen; 202 break label_2; 203 } 204 Statement(); 205 } 206 jj_consume_token(RCURLY); 207 } catch (Throwable jjte000) { 208 if (jjtc000) { 209 jjtree.clearNodeScope(jjtn000); 210 jjtc000 = false; 211 } else { 212 jjtree.popNode(); 213 } 214 if (jjte000 instanceof RuntimeException) { 215 {if (true) throw (RuntimeException)jjte000;} 216 } 217 if (jjte000 instanceof ParseException) { 218 {if (true) throw (ParseException)jjte000;} 219 } 220 {if (true) throw (Error)jjte000;} 221 } finally { 222 if (jjtc000) { 223 jjtree.closeNodeScope(jjtn000, true); 224 jjtreeCloseNodeScope(jjtn000); 225 } 226 } 227 } 228 229 final public void ExpressionStatement() throws ParseException { 230 Expression(); 231 label_3: 232 while (true) { 233 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 234 case NEW: 235 case EMPTY: 236 case SIZE: 237 case NULL: 238 case TRUE: 239 case FALSE: 240 case LPAREN: 241 case LCURLY: 242 case LBRACKET: 243 case not: 244 case minus: 245 case tilda: 246 case IDENTIFIER: 247 case REGISTER: 248 case INTEGER_LITERAL: 249 case FLOAT_LITERAL: 250 case STRING_LITERAL: 251 ; 252 break; 253 default: 254 jj_la1[4] = jj_gen; 255 break label_3; 256 } 257 ASTAmbiguous jjtn001 = new ASTAmbiguous(JJTAMBIGUOUS); 258 boolean jjtc001 = true; 259 jjtree.openNodeScope(jjtn001); 260 jjtreeOpenNodeScope(jjtn001); 261 try { 262 Expression(); 263 } catch (Throwable jjte001) { 264 if (jjtc001) { 265 jjtree.clearNodeScope(jjtn001); 266 jjtc001 = false; 267 } else { 268 jjtree.popNode(); 269 } 270 if (jjte001 instanceof RuntimeException) { 271 {if (true) throw (RuntimeException)jjte001;} 272 } 273 if (jjte001 instanceof ParseException) { 274 {if (true) throw (ParseException)jjte001;} 275 } 276 {if (true) throw (Error)jjte001;} 277 } finally { 278 if (jjtc001) { 279 jjtree.closeNodeScope(jjtn001, true); 280 jjtreeCloseNodeScope(jjtn001); 281 } 282 } 283 } 284 if (jj_2_2(2)) { 285 jj_consume_token(SEMICOL); 286 } else { 287 ; 288 } 289 } 290 291 final public void IfStatement() throws ParseException { 292 /*@bgen(jjtree) IfStatement */ 293 ASTIfStatement jjtn000 = new ASTIfStatement(JJTIFSTATEMENT); 294 boolean jjtc000 = true; 295 jjtree.openNodeScope(jjtn000); 296 jjtreeOpenNodeScope(jjtn000); 297 try { 298 jj_consume_token(IF); 299 jj_consume_token(LPAREN); 300 Expression(); 301 jj_consume_token(RPAREN); 302 Statement(); 303 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 304 case ELSE: 305 jj_consume_token(ELSE); 306 Statement(); 307 break; 308 default: 309 jj_la1[5] = jj_gen; 310 ; 311 } 312 } catch (Throwable jjte000) { 313 if (jjtc000) { 314 jjtree.clearNodeScope(jjtn000); 315 jjtc000 = false; 316 } else { 317 jjtree.popNode(); 318 } 319 if (jjte000 instanceof RuntimeException) { 320 {if (true) throw (RuntimeException)jjte000;} 321 } 322 if (jjte000 instanceof ParseException) { 323 {if (true) throw (ParseException)jjte000;} 324 } 325 {if (true) throw (Error)jjte000;} 326 } finally { 327 if (jjtc000) { 328 jjtree.closeNodeScope(jjtn000, true); 329 jjtreeCloseNodeScope(jjtn000); 330 } 331 } 332 } 333 334 final public void WhileStatement() throws ParseException { 335 /*@bgen(jjtree) WhileStatement */ 336 ASTWhileStatement jjtn000 = new ASTWhileStatement(JJTWHILESTATEMENT); 337 boolean jjtc000 = true; 338 jjtree.openNodeScope(jjtn000); 339 jjtreeOpenNodeScope(jjtn000); 340 try { 341 jj_consume_token(WHILE); 342 jj_consume_token(LPAREN); 343 Expression(); 344 jj_consume_token(RPAREN); 345 Statement(); 346 } catch (Throwable jjte000) { 347 if (jjtc000) { 348 jjtree.clearNodeScope(jjtn000); 349 jjtc000 = false; 350 } else { 351 jjtree.popNode(); 352 } 353 if (jjte000 instanceof RuntimeException) { 354 {if (true) throw (RuntimeException)jjte000;} 355 } 356 if (jjte000 instanceof ParseException) { 357 {if (true) throw (ParseException)jjte000;} 358 } 359 {if (true) throw (Error)jjte000;} 360 } finally { 361 if (jjtc000) { 362 jjtree.closeNodeScope(jjtn000, true); 363 jjtreeCloseNodeScope(jjtn000); 364 } 365 } 366 } 367 368 final public void ForeachStatement() throws ParseException { 369 /*@bgen(jjtree) ForeachStatement */ 370 ASTForeachStatement jjtn000 = new ASTForeachStatement(JJTFOREACHSTATEMENT); 371 boolean jjtc000 = true; 372 jjtree.openNodeScope(jjtn000); 373 jjtreeOpenNodeScope(jjtn000); 374 try { 375 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 376 case FOR: 377 jj_consume_token(FOR); 378 jj_consume_token(LPAREN); 379 Reference(); 380 jj_consume_token(COLON); 381 Expression(); 382 jj_consume_token(RPAREN); 383 Statement(); 384 break; 385 case FOREACH: 386 jj_consume_token(FOREACH); 387 jj_consume_token(LPAREN); 388 Reference(); 389 jj_consume_token(IN); 390 Expression(); 391 jj_consume_token(RPAREN); 392 Statement(); 393 break; 394 default: 395 jj_la1[6] = jj_gen; 396 jj_consume_token(-1); 397 throw new ParseException(); 398 } 399 } catch (Throwable jjte000) { 400 if (jjtc000) { 401 jjtree.clearNodeScope(jjtn000); 402 jjtc000 = false; 403 } else { 404 jjtree.popNode(); 405 } 406 if (jjte000 instanceof RuntimeException) { 407 {if (true) throw (RuntimeException)jjte000;} 408 } 409 if (jjte000 instanceof ParseException) { 410 {if (true) throw (ParseException)jjte000;} 411 } 412 {if (true) throw (Error)jjte000;} 413 } finally { 414 if (jjtc000) { 415 jjtree.closeNodeScope(jjtn000, true); 416 jjtreeCloseNodeScope(jjtn000); 417 } 418 } 419 } 420 421 /*************************************** 422 * Expression syntax 423 ***************************************/ 424 final public void Expression() throws ParseException { 425 if (jj_2_3(2147483647)) { 426 Assignment(); 427 } else { 428 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 429 case NEW: 430 case EMPTY: 431 case SIZE: 432 case NULL: 433 case TRUE: 434 case FALSE: 435 case LPAREN: 436 case LCURLY: 437 case LBRACKET: 438 case not: 439 case minus: 440 case tilda: 441 case IDENTIFIER: 442 case REGISTER: 443 case INTEGER_LITERAL: 444 case FLOAT_LITERAL: 445 case STRING_LITERAL: 446 ConditionalExpression(); 447 break; 448 default: 449 jj_la1[7] = jj_gen; 450 jj_consume_token(-1); 451 throw new ParseException(); 452 } 453 } 454 } 455 456 final public void Assignment() throws ParseException { 457 /*@bgen(jjtree) #Assignment( 2) */ 458 ASTAssignment jjtn000 = new ASTAssignment(JJTASSIGNMENT); 459 boolean jjtc000 = true; 460 jjtree.openNodeScope(jjtn000); 461 jjtreeOpenNodeScope(jjtn000); 462 try { 463 Reference(); 464 jj_consume_token(assign); 465 Expression(); 466 } catch (Throwable jjte000) { 467 if (jjtc000) { 468 jjtree.clearNodeScope(jjtn000); 469 jjtc000 = false; 470 } else { 471 jjtree.popNode(); 472 } 473 if (jjte000 instanceof RuntimeException) { 474 {if (true) throw (RuntimeException)jjte000;} 475 } 476 if (jjte000 instanceof ParseException) { 477 {if (true) throw (ParseException)jjte000;} 478 } 479 {if (true) throw (Error)jjte000;} 480 } finally { 481 if (jjtc000) { 482 jjtree.closeNodeScope(jjtn000, 2); 483 jjtreeCloseNodeScope(jjtn000); 484 } 485 } 486 } 487 488 /*************************************** 489 * Conditional & relational 490 ***************************************/ 491 final public void ConditionalExpression() throws ParseException { 492 ConditionalOrExpression(); 493 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 494 case QMARK: 495 case ELVIS: 496 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 497 case QMARK: 498 jj_consume_token(QMARK); 499 Expression(); 500 jj_consume_token(COLON); 501 ASTTernaryNode jjtn001 = new ASTTernaryNode(JJTTERNARYNODE); 502 boolean jjtc001 = true; 503 jjtree.openNodeScope(jjtn001); 504 jjtreeOpenNodeScope(jjtn001); 505 try { 506 Expression(); 507 } catch (Throwable jjte001) { 508 if (jjtc001) { 509 jjtree.clearNodeScope(jjtn001); 510 jjtc001 = false; 511 } else { 512 jjtree.popNode(); 513 } 514 if (jjte001 instanceof RuntimeException) { 515 {if (true) throw (RuntimeException)jjte001;} 516 } 517 if (jjte001 instanceof ParseException) { 518 {if (true) throw (ParseException)jjte001;} 519 } 520 {if (true) throw (Error)jjte001;} 521 } finally { 522 if (jjtc001) { 523 jjtree.closeNodeScope(jjtn001, 3); 524 jjtreeCloseNodeScope(jjtn001); 525 } 526 } 527 break; 528 case ELVIS: 529 jj_consume_token(ELVIS); 530 ASTTernaryNode jjtn002 = new ASTTernaryNode(JJTTERNARYNODE); 531 boolean jjtc002 = true; 532 jjtree.openNodeScope(jjtn002); 533 jjtreeOpenNodeScope(jjtn002); 534 try { 535 Expression(); 536 } catch (Throwable jjte002) { 537 if (jjtc002) { 538 jjtree.clearNodeScope(jjtn002); 539 jjtc002 = false; 540 } else { 541 jjtree.popNode(); 542 } 543 if (jjte002 instanceof RuntimeException) { 544 {if (true) throw (RuntimeException)jjte002;} 545 } 546 if (jjte002 instanceof ParseException) { 547 {if (true) throw (ParseException)jjte002;} 548 } 549 {if (true) throw (Error)jjte002;} 550 } finally { 551 if (jjtc002) { 552 jjtree.closeNodeScope(jjtn002, 2); 553 jjtreeCloseNodeScope(jjtn002); 554 } 555 } 556 break; 557 default: 558 jj_la1[8] = jj_gen; 559 jj_consume_token(-1); 560 throw new ParseException(); 561 } 562 break; 563 default: 564 jj_la1[9] = jj_gen; 565 ; 566 } 567 } 568 569 final public void ConditionalOrExpression() throws ParseException { 570 ConditionalAndExpression(); 571 label_4: 572 while (true) { 573 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 574 case OR: 575 ; 576 break; 577 default: 578 jj_la1[10] = jj_gen; 579 break label_4; 580 } 581 jj_consume_token(OR); 582 ASTOrNode jjtn001 = new ASTOrNode(JJTORNODE); 583 boolean jjtc001 = true; 584 jjtree.openNodeScope(jjtn001); 585 jjtreeOpenNodeScope(jjtn001); 586 try { 587 ConditionalAndExpression(); 588 } catch (Throwable jjte001) { 589 if (jjtc001) { 590 jjtree.clearNodeScope(jjtn001); 591 jjtc001 = false; 592 } else { 593 jjtree.popNode(); 594 } 595 if (jjte001 instanceof RuntimeException) { 596 {if (true) throw (RuntimeException)jjte001;} 597 } 598 if (jjte001 instanceof ParseException) { 599 {if (true) throw (ParseException)jjte001;} 600 } 601 {if (true) throw (Error)jjte001;} 602 } finally { 603 if (jjtc001) { 604 jjtree.closeNodeScope(jjtn001, 2); 605 jjtreeCloseNodeScope(jjtn001); 606 } 607 } 608 } 609 } 610 611 final public void ConditionalAndExpression() throws ParseException { 612 InclusiveOrExpression(); 613 label_5: 614 while (true) { 615 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 616 case AND: 617 ; 618 break; 619 default: 620 jj_la1[11] = jj_gen; 621 break label_5; 622 } 623 jj_consume_token(AND); 624 ASTAndNode jjtn001 = new ASTAndNode(JJTANDNODE); 625 boolean jjtc001 = true; 626 jjtree.openNodeScope(jjtn001); 627 jjtreeOpenNodeScope(jjtn001); 628 try { 629 InclusiveOrExpression(); 630 } catch (Throwable jjte001) { 631 if (jjtc001) { 632 jjtree.clearNodeScope(jjtn001); 633 jjtc001 = false; 634 } else { 635 jjtree.popNode(); 636 } 637 if (jjte001 instanceof RuntimeException) { 638 {if (true) throw (RuntimeException)jjte001;} 639 } 640 if (jjte001 instanceof ParseException) { 641 {if (true) throw (ParseException)jjte001;} 642 } 643 {if (true) throw (Error)jjte001;} 644 } finally { 645 if (jjtc001) { 646 jjtree.closeNodeScope(jjtn001, 2); 647 jjtreeCloseNodeScope(jjtn001); 648 } 649 } 650 } 651 } 652 653 final public void InclusiveOrExpression() throws ParseException { 654 ExclusiveOrExpression(); 655 label_6: 656 while (true) { 657 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 658 case or: 659 ; 660 break; 661 default: 662 jj_la1[12] = jj_gen; 663 break label_6; 664 } 665 jj_consume_token(or); 666 ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(JJTBITWISEORNODE); 667 boolean jjtc001 = true; 668 jjtree.openNodeScope(jjtn001); 669 jjtreeOpenNodeScope(jjtn001); 670 try { 671 ExclusiveOrExpression(); 672 } catch (Throwable jjte001) { 673 if (jjtc001) { 674 jjtree.clearNodeScope(jjtn001); 675 jjtc001 = false; 676 } else { 677 jjtree.popNode(); 678 } 679 if (jjte001 instanceof RuntimeException) { 680 {if (true) throw (RuntimeException)jjte001;} 681 } 682 if (jjte001 instanceof ParseException) { 683 {if (true) throw (ParseException)jjte001;} 684 } 685 {if (true) throw (Error)jjte001;} 686 } finally { 687 if (jjtc001) { 688 jjtree.closeNodeScope(jjtn001, 2); 689 jjtreeCloseNodeScope(jjtn001); 690 } 691 } 692 } 693 } 694 695 final public void ExclusiveOrExpression() throws ParseException { 696 AndExpression(); 697 label_7: 698 while (true) { 699 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 700 case xor: 701 ; 702 break; 703 default: 704 jj_la1[13] = jj_gen; 705 break label_7; 706 } 707 jj_consume_token(xor); 708 ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(JJTBITWISEXORNODE); 709 boolean jjtc001 = true; 710 jjtree.openNodeScope(jjtn001); 711 jjtreeOpenNodeScope(jjtn001); 712 try { 713 AndExpression(); 714 } catch (Throwable jjte001) { 715 if (jjtc001) { 716 jjtree.clearNodeScope(jjtn001); 717 jjtc001 = false; 718 } else { 719 jjtree.popNode(); 720 } 721 if (jjte001 instanceof RuntimeException) { 722 {if (true) throw (RuntimeException)jjte001;} 723 } 724 if (jjte001 instanceof ParseException) { 725 {if (true) throw (ParseException)jjte001;} 726 } 727 {if (true) throw (Error)jjte001;} 728 } finally { 729 if (jjtc001) { 730 jjtree.closeNodeScope(jjtn001, 2); 731 jjtreeCloseNodeScope(jjtn001); 732 } 733 } 734 } 735 } 736 737 final public void AndExpression() throws ParseException { 738 EqualityExpression(); 739 label_8: 740 while (true) { 741 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 742 case and: 743 ; 744 break; 745 default: 746 jj_la1[14] = jj_gen; 747 break label_8; 748 } 749 jj_consume_token(and); 750 ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(JJTBITWISEANDNODE); 751 boolean jjtc001 = true; 752 jjtree.openNodeScope(jjtn001); 753 jjtreeOpenNodeScope(jjtn001); 754 try { 755 EqualityExpression(); 756 } catch (Throwable jjte001) { 757 if (jjtc001) { 758 jjtree.clearNodeScope(jjtn001); 759 jjtc001 = false; 760 } else { 761 jjtree.popNode(); 762 } 763 if (jjte001 instanceof RuntimeException) { 764 {if (true) throw (RuntimeException)jjte001;} 765 } 766 if (jjte001 instanceof ParseException) { 767 {if (true) throw (ParseException)jjte001;} 768 } 769 {if (true) throw (Error)jjte001;} 770 } finally { 771 if (jjtc001) { 772 jjtree.closeNodeScope(jjtn001, 2); 773 jjtreeCloseNodeScope(jjtn001); 774 } 775 } 776 } 777 } 778 779 final public void EqualityExpression() throws ParseException { 780 RelationalExpression(); 781 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 782 case eq: 783 case ne: 784 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 785 case eq: 786 jj_consume_token(eq); 787 ASTEQNode jjtn001 = new ASTEQNode(JJTEQNODE); 788 boolean jjtc001 = true; 789 jjtree.openNodeScope(jjtn001); 790 jjtreeOpenNodeScope(jjtn001); 791 try { 792 RelationalExpression(); 793 } catch (Throwable jjte001) { 794 if (jjtc001) { 795 jjtree.clearNodeScope(jjtn001); 796 jjtc001 = false; 797 } else { 798 jjtree.popNode(); 799 } 800 if (jjte001 instanceof RuntimeException) { 801 {if (true) throw (RuntimeException)jjte001;} 802 } 803 if (jjte001 instanceof ParseException) { 804 {if (true) throw (ParseException)jjte001;} 805 } 806 {if (true) throw (Error)jjte001;} 807 } finally { 808 if (jjtc001) { 809 jjtree.closeNodeScope(jjtn001, 2); 810 jjtreeCloseNodeScope(jjtn001); 811 } 812 } 813 break; 814 case ne: 815 jj_consume_token(ne); 816 ASTNENode jjtn002 = new ASTNENode(JJTNENODE); 817 boolean jjtc002 = true; 818 jjtree.openNodeScope(jjtn002); 819 jjtreeOpenNodeScope(jjtn002); 820 try { 821 RelationalExpression(); 822 } catch (Throwable jjte002) { 823 if (jjtc002) { 824 jjtree.clearNodeScope(jjtn002); 825 jjtc002 = false; 826 } else { 827 jjtree.popNode(); 828 } 829 if (jjte002 instanceof RuntimeException) { 830 {if (true) throw (RuntimeException)jjte002;} 831 } 832 if (jjte002 instanceof ParseException) { 833 {if (true) throw (ParseException)jjte002;} 834 } 835 {if (true) throw (Error)jjte002;} 836 } finally { 837 if (jjtc002) { 838 jjtree.closeNodeScope(jjtn002, 2); 839 jjtreeCloseNodeScope(jjtn002); 840 } 841 } 842 break; 843 default: 844 jj_la1[15] = jj_gen; 845 jj_consume_token(-1); 846 throw new ParseException(); 847 } 848 break; 849 default: 850 jj_la1[16] = jj_gen; 851 ; 852 } 853 } 854 855 final public void RelationalExpression() throws ParseException { 856 AdditiveExpression(); 857 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 858 case req: 859 case rne: 860 case gt: 861 case ge: 862 case lt: 863 case le: 864 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 865 case lt: 866 jj_consume_token(lt); 867 ASTLTNode jjtn001 = new ASTLTNode(JJTLTNODE); 868 boolean jjtc001 = true; 869 jjtree.openNodeScope(jjtn001); 870 jjtreeOpenNodeScope(jjtn001); 871 try { 872 AdditiveExpression(); 873 } catch (Throwable jjte001) { 874 if (jjtc001) { 875 jjtree.clearNodeScope(jjtn001); 876 jjtc001 = false; 877 } else { 878 jjtree.popNode(); 879 } 880 if (jjte001 instanceof RuntimeException) { 881 {if (true) throw (RuntimeException)jjte001;} 882 } 883 if (jjte001 instanceof ParseException) { 884 {if (true) throw (ParseException)jjte001;} 885 } 886 {if (true) throw (Error)jjte001;} 887 } finally { 888 if (jjtc001) { 889 jjtree.closeNodeScope(jjtn001, 2); 890 jjtreeCloseNodeScope(jjtn001); 891 } 892 } 893 break; 894 case gt: 895 jj_consume_token(gt); 896 ASTGTNode jjtn002 = new ASTGTNode(JJTGTNODE); 897 boolean jjtc002 = true; 898 jjtree.openNodeScope(jjtn002); 899 jjtreeOpenNodeScope(jjtn002); 900 try { 901 AdditiveExpression(); 902 } catch (Throwable jjte002) { 903 if (jjtc002) { 904 jjtree.clearNodeScope(jjtn002); 905 jjtc002 = false; 906 } else { 907 jjtree.popNode(); 908 } 909 if (jjte002 instanceof RuntimeException) { 910 {if (true) throw (RuntimeException)jjte002;} 911 } 912 if (jjte002 instanceof ParseException) { 913 {if (true) throw (ParseException)jjte002;} 914 } 915 {if (true) throw (Error)jjte002;} 916 } finally { 917 if (jjtc002) { 918 jjtree.closeNodeScope(jjtn002, 2); 919 jjtreeCloseNodeScope(jjtn002); 920 } 921 } 922 break; 923 case le: 924 jj_consume_token(le); 925 ASTLENode jjtn003 = new ASTLENode(JJTLENODE); 926 boolean jjtc003 = true; 927 jjtree.openNodeScope(jjtn003); 928 jjtreeOpenNodeScope(jjtn003); 929 try { 930 AdditiveExpression(); 931 } catch (Throwable jjte003) { 932 if (jjtc003) { 933 jjtree.clearNodeScope(jjtn003); 934 jjtc003 = false; 935 } else { 936 jjtree.popNode(); 937 } 938 if (jjte003 instanceof RuntimeException) { 939 {if (true) throw (RuntimeException)jjte003;} 940 } 941 if (jjte003 instanceof ParseException) { 942 {if (true) throw (ParseException)jjte003;} 943 } 944 {if (true) throw (Error)jjte003;} 945 } finally { 946 if (jjtc003) { 947 jjtree.closeNodeScope(jjtn003, 2); 948 jjtreeCloseNodeScope(jjtn003); 949 } 950 } 951 break; 952 case ge: 953 jj_consume_token(ge); 954 ASTGENode jjtn004 = new ASTGENode(JJTGENODE); 955 boolean jjtc004 = true; 956 jjtree.openNodeScope(jjtn004); 957 jjtreeOpenNodeScope(jjtn004); 958 try { 959 AdditiveExpression(); 960 } catch (Throwable jjte004) { 961 if (jjtc004) { 962 jjtree.clearNodeScope(jjtn004); 963 jjtc004 = false; 964 } else { 965 jjtree.popNode(); 966 } 967 if (jjte004 instanceof RuntimeException) { 968 {if (true) throw (RuntimeException)jjte004;} 969 } 970 if (jjte004 instanceof ParseException) { 971 {if (true) throw (ParseException)jjte004;} 972 } 973 {if (true) throw (Error)jjte004;} 974 } finally { 975 if (jjtc004) { 976 jjtree.closeNodeScope(jjtn004, 2); 977 jjtreeCloseNodeScope(jjtn004); 978 } 979 } 980 break; 981 case req: 982 jj_consume_token(req); 983 ASTERNode jjtn005 = new ASTERNode(JJTERNODE); 984 boolean jjtc005 = true; 985 jjtree.openNodeScope(jjtn005); 986 jjtreeOpenNodeScope(jjtn005); 987 try { 988 AdditiveExpression(); 989 } catch (Throwable jjte005) { 990 if (jjtc005) { 991 jjtree.clearNodeScope(jjtn005); 992 jjtc005 = false; 993 } else { 994 jjtree.popNode(); 995 } 996 if (jjte005 instanceof RuntimeException) { 997 {if (true) throw (RuntimeException)jjte005;} 998 } 999 if (jjte005 instanceof ParseException) { 1000 {if (true) throw (ParseException)jjte005;} 1001 } 1002 {if (true) throw (Error)jjte005;} 1003 } finally { 1004 if (jjtc005) { 1005 jjtree.closeNodeScope(jjtn005, 2); 1006 jjtreeCloseNodeScope(jjtn005); 1007 } 1008 } 1009 break; 1010 case rne: 1011 jj_consume_token(rne); 1012 ASTNRNode jjtn006 = new ASTNRNode(JJTNRNODE); 1013 boolean jjtc006 = true; 1014 jjtree.openNodeScope(jjtn006); 1015 jjtreeOpenNodeScope(jjtn006); 1016 try { 1017 AdditiveExpression(); 1018 } catch (Throwable jjte006) { 1019 if (jjtc006) { 1020 jjtree.clearNodeScope(jjtn006); 1021 jjtc006 = false; 1022 } else { 1023 jjtree.popNode(); 1024 } 1025 if (jjte006 instanceof RuntimeException) { 1026 {if (true) throw (RuntimeException)jjte006;} 1027 } 1028 if (jjte006 instanceof ParseException) { 1029 {if (true) throw (ParseException)jjte006;} 1030 } 1031 {if (true) throw (Error)jjte006;} 1032 } finally { 1033 if (jjtc006) { 1034 jjtree.closeNodeScope(jjtn006, 2); 1035 jjtreeCloseNodeScope(jjtn006); 1036 } 1037 } 1038 break; 1039 default: 1040 jj_la1[17] = jj_gen; 1041 jj_consume_token(-1); 1042 throw new ParseException(); 1043 } 1044 break; 1045 default: 1046 jj_la1[18] = jj_gen; 1047 ; 1048 } 1049 } 1050 1051 /*************************************** 1052 * Arithmetic 1053 ***************************************/ 1054 final public void AdditiveExpression() throws ParseException { 1055 /*@bgen(jjtree) #AdditiveNode(> 1) */ 1056 ASTAdditiveNode jjtn000 = new ASTAdditiveNode(JJTADDITIVENODE); 1057 boolean jjtc000 = true; 1058 jjtree.openNodeScope(jjtn000); 1059 jjtreeOpenNodeScope(jjtn000); 1060 try { 1061 MultiplicativeExpression(); 1062 label_9: 1063 while (true) { 1064 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1065 case plus: 1066 case minus: 1067 ; 1068 break; 1069 default: 1070 jj_la1[19] = jj_gen; 1071 break label_9; 1072 } 1073 AdditiveOperator(); 1074 MultiplicativeExpression(); 1075 } 1076 } catch (Throwable jjte000) { 1077 if (jjtc000) { 1078 jjtree.clearNodeScope(jjtn000); 1079 jjtc000 = false; 1080 } else { 1081 jjtree.popNode(); 1082 } 1083 if (jjte000 instanceof RuntimeException) { 1084 {if (true) throw (RuntimeException)jjte000;} 1085 } 1086 if (jjte000 instanceof ParseException) { 1087 {if (true) throw (ParseException)jjte000;} 1088 } 1089 {if (true) throw (Error)jjte000;} 1090 } finally { 1091 if (jjtc000) { 1092 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1); 1093 jjtreeCloseNodeScope(jjtn000); 1094 } 1095 } 1096 } 1097 1098 final public void AdditiveOperator() throws ParseException { 1099 /*@bgen(jjtree) AdditiveOperator */ 1100 ASTAdditiveOperator jjtn000 = new ASTAdditiveOperator(JJTADDITIVEOPERATOR); 1101 boolean jjtc000 = true; 1102 jjtree.openNodeScope(jjtn000); 1103 jjtreeOpenNodeScope(jjtn000); 1104 try { 1105 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1106 case plus: 1107 jj_consume_token(plus); 1108 jjtree.closeNodeScope(jjtn000, true); 1109 jjtc000 = false; 1110 jjtreeCloseNodeScope(jjtn000); 1111 jjtn000.image = "+"; 1112 break; 1113 case minus: 1114 jj_consume_token(minus); 1115 jjtree.closeNodeScope(jjtn000, true); 1116 jjtc000 = false; 1117 jjtreeCloseNodeScope(jjtn000); 1118 jjtn000.image = "-"; 1119 break; 1120 default: 1121 jj_la1[20] = jj_gen; 1122 jj_consume_token(-1); 1123 throw new ParseException(); 1124 } 1125 } finally { 1126 if (jjtc000) { 1127 jjtree.closeNodeScope(jjtn000, true); 1128 jjtreeCloseNodeScope(jjtn000); 1129 } 1130 } 1131 } 1132 1133 final public void MultiplicativeExpression() throws ParseException { 1134 UnaryExpression(); 1135 label_10: 1136 while (true) { 1137 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1138 case mod: 1139 case div: 1140 case mult: 1141 ; 1142 break; 1143 default: 1144 jj_la1[21] = jj_gen; 1145 break label_10; 1146 } 1147 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1148 case mult: 1149 jj_consume_token(mult); 1150 ASTMulNode jjtn001 = new ASTMulNode(JJTMULNODE); 1151 boolean jjtc001 = true; 1152 jjtree.openNodeScope(jjtn001); 1153 jjtreeOpenNodeScope(jjtn001); 1154 try { 1155 UnaryExpression(); 1156 } catch (Throwable jjte001) { 1157 if (jjtc001) { 1158 jjtree.clearNodeScope(jjtn001); 1159 jjtc001 = false; 1160 } else { 1161 jjtree.popNode(); 1162 } 1163 if (jjte001 instanceof RuntimeException) { 1164 {if (true) throw (RuntimeException)jjte001;} 1165 } 1166 if (jjte001 instanceof ParseException) { 1167 {if (true) throw (ParseException)jjte001;} 1168 } 1169 {if (true) throw (Error)jjte001;} 1170 } finally { 1171 if (jjtc001) { 1172 jjtree.closeNodeScope(jjtn001, 2); 1173 jjtreeCloseNodeScope(jjtn001); 1174 } 1175 } 1176 break; 1177 case div: 1178 jj_consume_token(div); 1179 ASTDivNode jjtn002 = new ASTDivNode(JJTDIVNODE); 1180 boolean jjtc002 = true; 1181 jjtree.openNodeScope(jjtn002); 1182 jjtreeOpenNodeScope(jjtn002); 1183 try { 1184 UnaryExpression(); 1185 } catch (Throwable jjte002) { 1186 if (jjtc002) { 1187 jjtree.clearNodeScope(jjtn002); 1188 jjtc002 = false; 1189 } else { 1190 jjtree.popNode(); 1191 } 1192 if (jjte002 instanceof RuntimeException) { 1193 {if (true) throw (RuntimeException)jjte002;} 1194 } 1195 if (jjte002 instanceof ParseException) { 1196 {if (true) throw (ParseException)jjte002;} 1197 } 1198 {if (true) throw (Error)jjte002;} 1199 } finally { 1200 if (jjtc002) { 1201 jjtree.closeNodeScope(jjtn002, 2); 1202 jjtreeCloseNodeScope(jjtn002); 1203 } 1204 } 1205 break; 1206 case mod: 1207 jj_consume_token(mod); 1208 ASTModNode jjtn003 = new ASTModNode(JJTMODNODE); 1209 boolean jjtc003 = true; 1210 jjtree.openNodeScope(jjtn003); 1211 jjtreeOpenNodeScope(jjtn003); 1212 try { 1213 UnaryExpression(); 1214 } catch (Throwable jjte003) { 1215 if (jjtc003) { 1216 jjtree.clearNodeScope(jjtn003); 1217 jjtc003 = false; 1218 } else { 1219 jjtree.popNode(); 1220 } 1221 if (jjte003 instanceof RuntimeException) { 1222 {if (true) throw (RuntimeException)jjte003;} 1223 } 1224 if (jjte003 instanceof ParseException) { 1225 {if (true) throw (ParseException)jjte003;} 1226 } 1227 {if (true) throw (Error)jjte003;} 1228 } finally { 1229 if (jjtc003) { 1230 jjtree.closeNodeScope(jjtn003, 2); 1231 jjtreeCloseNodeScope(jjtn003); 1232 } 1233 } 1234 break; 1235 default: 1236 jj_la1[22] = jj_gen; 1237 jj_consume_token(-1); 1238 throw new ParseException(); 1239 } 1240 } 1241 } 1242 1243 final public void UnaryExpression() throws ParseException { 1244 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1245 case minus: 1246 jj_consume_token(minus); 1247 ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(JJTUNARYMINUSNODE); 1248 boolean jjtc001 = true; 1249 jjtree.openNodeScope(jjtn001); 1250 jjtreeOpenNodeScope(jjtn001); 1251 try { 1252 UnaryExpression(); 1253 } catch (Throwable jjte001) { 1254 if (jjtc001) { 1255 jjtree.clearNodeScope(jjtn001); 1256 jjtc001 = false; 1257 } else { 1258 jjtree.popNode(); 1259 } 1260 if (jjte001 instanceof RuntimeException) { 1261 {if (true) throw (RuntimeException)jjte001;} 1262 } 1263 if (jjte001 instanceof ParseException) { 1264 {if (true) throw (ParseException)jjte001;} 1265 } 1266 {if (true) throw (Error)jjte001;} 1267 } finally { 1268 if (jjtc001) { 1269 jjtree.closeNodeScope(jjtn001, 1); 1270 jjtreeCloseNodeScope(jjtn001); 1271 } 1272 } 1273 break; 1274 case tilda: 1275 jj_consume_token(tilda); 1276 ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(JJTBITWISECOMPLNODE); 1277 boolean jjtc002 = true; 1278 jjtree.openNodeScope(jjtn002); 1279 jjtreeOpenNodeScope(jjtn002); 1280 try { 1281 UnaryExpression(); 1282 } catch (Throwable jjte002) { 1283 if (jjtc002) { 1284 jjtree.clearNodeScope(jjtn002); 1285 jjtc002 = false; 1286 } else { 1287 jjtree.popNode(); 1288 } 1289 if (jjte002 instanceof RuntimeException) { 1290 {if (true) throw (RuntimeException)jjte002;} 1291 } 1292 if (jjte002 instanceof ParseException) { 1293 {if (true) throw (ParseException)jjte002;} 1294 } 1295 {if (true) throw (Error)jjte002;} 1296 } finally { 1297 if (jjtc002) { 1298 jjtree.closeNodeScope(jjtn002, 1); 1299 jjtreeCloseNodeScope(jjtn002); 1300 } 1301 } 1302 break; 1303 case not: 1304 jj_consume_token(not); 1305 ASTNotNode jjtn003 = new ASTNotNode(JJTNOTNODE); 1306 boolean jjtc003 = true; 1307 jjtree.openNodeScope(jjtn003); 1308 jjtreeOpenNodeScope(jjtn003); 1309 try { 1310 UnaryExpression(); 1311 } catch (Throwable jjte003) { 1312 if (jjtc003) { 1313 jjtree.clearNodeScope(jjtn003); 1314 jjtc003 = false; 1315 } else { 1316 jjtree.popNode(); 1317 } 1318 if (jjte003 instanceof RuntimeException) { 1319 {if (true) throw (RuntimeException)jjte003;} 1320 } 1321 if (jjte003 instanceof ParseException) { 1322 {if (true) throw (ParseException)jjte003;} 1323 } 1324 {if (true) throw (Error)jjte003;} 1325 } finally { 1326 if (jjtc003) { 1327 jjtree.closeNodeScope(jjtn003, 1); 1328 jjtreeCloseNodeScope(jjtn003); 1329 } 1330 } 1331 break; 1332 case NEW: 1333 case EMPTY: 1334 case SIZE: 1335 case NULL: 1336 case TRUE: 1337 case FALSE: 1338 case LPAREN: 1339 case LCURLY: 1340 case LBRACKET: 1341 case IDENTIFIER: 1342 case REGISTER: 1343 case INTEGER_LITERAL: 1344 case FLOAT_LITERAL: 1345 case STRING_LITERAL: 1346 PrimaryExpression(); 1347 break; 1348 default: 1349 jj_la1[23] = jj_gen; 1350 jj_consume_token(-1); 1351 throw new ParseException(); 1352 } 1353 } 1354 1355 /*************************************** 1356 * Identifier & Literals 1357 ***************************************/ 1358 final public void Identifier() throws ParseException { 1359 /*@bgen(jjtree) Identifier */ 1360 ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER); 1361 boolean jjtc000 = true; 1362 jjtree.openNodeScope(jjtn000); 1363 jjtreeOpenNodeScope(jjtn000);Token t; 1364 try { 1365 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1366 case IDENTIFIER: 1367 t = jj_consume_token(IDENTIFIER); 1368 jjtree.closeNodeScope(jjtn000, true); 1369 jjtc000 = false; 1370 jjtreeCloseNodeScope(jjtn000); 1371 jjtn000.image = t.image; 1372 break; 1373 case REGISTER: 1374 t = jj_consume_token(REGISTER); 1375 jjtree.closeNodeScope(jjtn000, true); 1376 jjtc000 = false; 1377 jjtreeCloseNodeScope(jjtn000); 1378 jjtn000.image = t.image; 1379 break; 1380 default: 1381 jj_la1[24] = jj_gen; 1382 jj_consume_token(-1); 1383 throw new ParseException(); 1384 } 1385 } finally { 1386 if (jjtc000) { 1387 jjtree.closeNodeScope(jjtn000, true); 1388 jjtreeCloseNodeScope(jjtn000); 1389 } 1390 } 1391 } 1392 1393 final public void Literal() throws ParseException { 1394 Token t; 1395 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1396 case INTEGER_LITERAL: 1397 IntegerLiteral(); 1398 break; 1399 case FLOAT_LITERAL: 1400 FloatLiteral(); 1401 break; 1402 case TRUE: 1403 case FALSE: 1404 BooleanLiteral(); 1405 break; 1406 case STRING_LITERAL: 1407 StringLiteral(); 1408 break; 1409 case NULL: 1410 NullLiteral(); 1411 break; 1412 default: 1413 jj_la1[25] = jj_gen; 1414 jj_consume_token(-1); 1415 throw new ParseException(); 1416 } 1417 } 1418 1419 final public void NullLiteral() throws ParseException { 1420 /*@bgen(jjtree) NullLiteral */ 1421 ASTNullLiteral jjtn000 = new ASTNullLiteral(JJTNULLLITERAL); 1422 boolean jjtc000 = true; 1423 jjtree.openNodeScope(jjtn000); 1424 jjtreeOpenNodeScope(jjtn000); 1425 try { 1426 jj_consume_token(NULL); 1427 } finally { 1428 if (jjtc000) { 1429 jjtree.closeNodeScope(jjtn000, true); 1430 jjtreeCloseNodeScope(jjtn000); 1431 } 1432 } 1433 } 1434 1435 final public void BooleanLiteral() throws ParseException { 1436 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1437 case TRUE: 1438 ASTTrueNode jjtn001 = new ASTTrueNode(JJTTRUENODE); 1439 boolean jjtc001 = true; 1440 jjtree.openNodeScope(jjtn001); 1441 jjtreeOpenNodeScope(jjtn001); 1442 try { 1443 jj_consume_token(TRUE); 1444 } finally { 1445 if (jjtc001) { 1446 jjtree.closeNodeScope(jjtn001, true); 1447 jjtreeCloseNodeScope(jjtn001); 1448 } 1449 } 1450 break; 1451 case FALSE: 1452 ASTFalseNode jjtn002 = new ASTFalseNode(JJTFALSENODE); 1453 boolean jjtc002 = true; 1454 jjtree.openNodeScope(jjtn002); 1455 jjtreeOpenNodeScope(jjtn002); 1456 try { 1457 jj_consume_token(FALSE); 1458 } finally { 1459 if (jjtc002) { 1460 jjtree.closeNodeScope(jjtn002, true); 1461 jjtreeCloseNodeScope(jjtn002); 1462 } 1463 } 1464 break; 1465 default: 1466 jj_la1[26] = jj_gen; 1467 jj_consume_token(-1); 1468 throw new ParseException(); 1469 } 1470 } 1471 1472 final public void IntegerLiteral() throws ParseException { 1473 /*@bgen(jjtree) IntegerLiteral */ 1474 ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(JJTINTEGERLITERAL); 1475 boolean jjtc000 = true; 1476 jjtree.openNodeScope(jjtn000); 1477 jjtreeOpenNodeScope(jjtn000);Token t; 1478 try { 1479 t = jj_consume_token(INTEGER_LITERAL); 1480 jjtree.closeNodeScope(jjtn000, true); 1481 jjtc000 = false; 1482 jjtreeCloseNodeScope(jjtn000); 1483 jjtn000.image = t.image; jjtn000.literal = Integer.valueOf(t.image); 1484 } finally { 1485 if (jjtc000) { 1486 jjtree.closeNodeScope(jjtn000, true); 1487 jjtreeCloseNodeScope(jjtn000); 1488 } 1489 } 1490 } 1491 1492 final public void FloatLiteral() throws ParseException { 1493 /*@bgen(jjtree) FloatLiteral */ 1494 ASTFloatLiteral jjtn000 = new ASTFloatLiteral(JJTFLOATLITERAL); 1495 boolean jjtc000 = true; 1496 jjtree.openNodeScope(jjtn000); 1497 jjtreeOpenNodeScope(jjtn000);Token t; 1498 try { 1499 t = jj_consume_token(FLOAT_LITERAL); 1500 jjtree.closeNodeScope(jjtn000, true); 1501 jjtc000 = false; 1502 jjtreeCloseNodeScope(jjtn000); 1503 jjtn000.image = t.image; jjtn000.literal = Float.valueOf(t.image); 1504 } finally { 1505 if (jjtc000) { 1506 jjtree.closeNodeScope(jjtn000, true); 1507 jjtreeCloseNodeScope(jjtn000); 1508 } 1509 } 1510 } 1511 1512 final public void StringLiteral() throws ParseException { 1513 /*@bgen(jjtree) StringLiteral */ 1514 ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL); 1515 boolean jjtc000 = true; 1516 jjtree.openNodeScope(jjtn000); 1517 jjtreeOpenNodeScope(jjtn000);Token t; 1518 try { 1519 t = jj_consume_token(STRING_LITERAL); 1520 jjtree.closeNodeScope(jjtn000, true); 1521 jjtc000 = false; 1522 jjtreeCloseNodeScope(jjtn000); 1523 jjtn000.image = Parser.buildString(t.image, true); 1524 } finally { 1525 if (jjtc000) { 1526 jjtree.closeNodeScope(jjtn000, true); 1527 jjtreeCloseNodeScope(jjtn000); 1528 } 1529 } 1530 } 1531 1532 final public void ArrayLiteral() throws ParseException { 1533 /*@bgen(jjtree) ArrayLiteral */ 1534 ASTArrayLiteral jjtn000 = new ASTArrayLiteral(JJTARRAYLITERAL); 1535 boolean jjtc000 = true; 1536 jjtree.openNodeScope(jjtn000); 1537 jjtreeOpenNodeScope(jjtn000); 1538 try { 1539 jj_consume_token(LBRACKET); 1540 Expression(); 1541 label_11: 1542 while (true) { 1543 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1544 case COMMA: 1545 ; 1546 break; 1547 default: 1548 jj_la1[27] = jj_gen; 1549 break label_11; 1550 } 1551 jj_consume_token(COMMA); 1552 Expression(); 1553 } 1554 jj_consume_token(RBRACKET); 1555 } catch (Throwable jjte000) { 1556 if (jjtc000) { 1557 jjtree.clearNodeScope(jjtn000); 1558 jjtc000 = false; 1559 } else { 1560 jjtree.popNode(); 1561 } 1562 if (jjte000 instanceof RuntimeException) { 1563 {if (true) throw (RuntimeException)jjte000;} 1564 } 1565 if (jjte000 instanceof ParseException) { 1566 {if (true) throw (ParseException)jjte000;} 1567 } 1568 {if (true) throw (Error)jjte000;} 1569 } finally { 1570 if (jjtc000) { 1571 jjtree.closeNodeScope(jjtn000, true); 1572 jjtreeCloseNodeScope(jjtn000); 1573 } 1574 } 1575 } 1576 1577 final public void MapLiteral() throws ParseException { 1578 /*@bgen(jjtree) MapLiteral */ 1579 ASTMapLiteral jjtn000 = new ASTMapLiteral(JJTMAPLITERAL); 1580 boolean jjtc000 = true; 1581 jjtree.openNodeScope(jjtn000); 1582 jjtreeOpenNodeScope(jjtn000); 1583 try { 1584 jj_consume_token(LCURLY); 1585 MapEntry(); 1586 label_12: 1587 while (true) { 1588 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1589 case COMMA: 1590 ; 1591 break; 1592 default: 1593 jj_la1[28] = jj_gen; 1594 break label_12; 1595 } 1596 jj_consume_token(COMMA); 1597 MapEntry(); 1598 } 1599 jj_consume_token(RCURLY); 1600 } catch (Throwable jjte000) { 1601 if (jjtc000) { 1602 jjtree.clearNodeScope(jjtn000); 1603 jjtc000 = false; 1604 } else { 1605 jjtree.popNode(); 1606 } 1607 if (jjte000 instanceof RuntimeException) { 1608 {if (true) throw (RuntimeException)jjte000;} 1609 } 1610 if (jjte000 instanceof ParseException) { 1611 {if (true) throw (ParseException)jjte000;} 1612 } 1613 {if (true) throw (Error)jjte000;} 1614 } finally { 1615 if (jjtc000) { 1616 jjtree.closeNodeScope(jjtn000, true); 1617 jjtreeCloseNodeScope(jjtn000); 1618 } 1619 } 1620 } 1621 1622 final public void MapEntry() throws ParseException { 1623 /*@bgen(jjtree) MapEntry */ 1624 ASTMapEntry jjtn000 = new ASTMapEntry(JJTMAPENTRY); 1625 boolean jjtc000 = true; 1626 jjtree.openNodeScope(jjtn000); 1627 jjtreeOpenNodeScope(jjtn000); 1628 try { 1629 Expression(); 1630 jj_consume_token(COLON); 1631 Expression(); 1632 } catch (Throwable jjte000) { 1633 if (jjtc000) { 1634 jjtree.clearNodeScope(jjtn000); 1635 jjtc000 = false; 1636 } else { 1637 jjtree.popNode(); 1638 } 1639 if (jjte000 instanceof RuntimeException) { 1640 {if (true) throw (RuntimeException)jjte000;} 1641 } 1642 if (jjte000 instanceof ParseException) { 1643 {if (true) throw (ParseException)jjte000;} 1644 } 1645 {if (true) throw (Error)jjte000;} 1646 } finally { 1647 if (jjtc000) { 1648 jjtree.closeNodeScope(jjtn000, true); 1649 jjtreeCloseNodeScope(jjtn000); 1650 } 1651 } 1652 } 1653 1654 /*************************************** 1655 * Functions & Methods 1656 ***************************************/ 1657 final public void EmptyFunction() throws ParseException { 1658 /*@bgen(jjtree) EmptyFunction */ 1659 ASTEmptyFunction jjtn000 = new ASTEmptyFunction(JJTEMPTYFUNCTION); 1660 boolean jjtc000 = true; 1661 jjtree.openNodeScope(jjtn000); 1662 jjtreeOpenNodeScope(jjtn000); 1663 try { 1664 if (jj_2_4(3)) { 1665 jj_consume_token(EMPTY); 1666 jj_consume_token(LPAREN); 1667 Expression(); 1668 jj_consume_token(RPAREN); 1669 } else { 1670 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1671 case EMPTY: 1672 jj_consume_token(EMPTY); 1673 Reference(); 1674 break; 1675 default: 1676 jj_la1[29] = jj_gen; 1677 jj_consume_token(-1); 1678 throw new ParseException(); 1679 } 1680 } 1681 } catch (Throwable jjte000) { 1682 if (jjtc000) { 1683 jjtree.clearNodeScope(jjtn000); 1684 jjtc000 = false; 1685 } else { 1686 jjtree.popNode(); 1687 } 1688 if (jjte000 instanceof RuntimeException) { 1689 {if (true) throw (RuntimeException)jjte000;} 1690 } 1691 if (jjte000 instanceof ParseException) { 1692 {if (true) throw (ParseException)jjte000;} 1693 } 1694 {if (true) throw (Error)jjte000;} 1695 } finally { 1696 if (jjtc000) { 1697 jjtree.closeNodeScope(jjtn000, true); 1698 jjtreeCloseNodeScope(jjtn000); 1699 } 1700 } 1701 } 1702 1703 final public void SizeFunction() throws ParseException { 1704 /*@bgen(jjtree) SizeFunction */ 1705 ASTSizeFunction jjtn000 = new ASTSizeFunction(JJTSIZEFUNCTION); 1706 boolean jjtc000 = true; 1707 jjtree.openNodeScope(jjtn000); 1708 jjtreeOpenNodeScope(jjtn000); 1709 try { 1710 jj_consume_token(SIZE); 1711 jj_consume_token(LPAREN); 1712 Expression(); 1713 jj_consume_token(RPAREN); 1714 } catch (Throwable jjte000) { 1715 if (jjtc000) { 1716 jjtree.clearNodeScope(jjtn000); 1717 jjtc000 = false; 1718 } else { 1719 jjtree.popNode(); 1720 } 1721 if (jjte000 instanceof RuntimeException) { 1722 {if (true) throw (RuntimeException)jjte000;} 1723 } 1724 if (jjte000 instanceof ParseException) { 1725 {if (true) throw (ParseException)jjte000;} 1726 } 1727 {if (true) throw (Error)jjte000;} 1728 } finally { 1729 if (jjtc000) { 1730 jjtree.closeNodeScope(jjtn000, true); 1731 jjtreeCloseNodeScope(jjtn000); 1732 } 1733 } 1734 } 1735 1736 final public void Function() throws ParseException { 1737 /*@bgen(jjtree) FunctionNode */ 1738 ASTFunctionNode jjtn000 = new ASTFunctionNode(JJTFUNCTIONNODE); 1739 boolean jjtc000 = true; 1740 jjtree.openNodeScope(jjtn000); 1741 jjtreeOpenNodeScope(jjtn000); 1742 try { 1743 Identifier(); 1744 jj_consume_token(COLON); 1745 Identifier(); 1746 jj_consume_token(LPAREN); 1747 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1748 case NEW: 1749 case EMPTY: 1750 case SIZE: 1751 case NULL: 1752 case TRUE: 1753 case FALSE: 1754 case LPAREN: 1755 case LCURLY: 1756 case LBRACKET: 1757 case not: 1758 case minus: 1759 case tilda: 1760 case IDENTIFIER: 1761 case REGISTER: 1762 case INTEGER_LITERAL: 1763 case FLOAT_LITERAL: 1764 case STRING_LITERAL: 1765 Expression(); 1766 label_13: 1767 while (true) { 1768 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1769 case COMMA: 1770 ; 1771 break; 1772 default: 1773 jj_la1[30] = jj_gen; 1774 break label_13; 1775 } 1776 jj_consume_token(COMMA); 1777 Expression(); 1778 } 1779 break; 1780 default: 1781 jj_la1[31] = jj_gen; 1782 ; 1783 } 1784 jj_consume_token(RPAREN); 1785 } catch (Throwable jjte000) { 1786 if (jjtc000) { 1787 jjtree.clearNodeScope(jjtn000); 1788 jjtc000 = false; 1789 } else { 1790 jjtree.popNode(); 1791 } 1792 if (jjte000 instanceof RuntimeException) { 1793 {if (true) throw (RuntimeException)jjte000;} 1794 } 1795 if (jjte000 instanceof ParseException) { 1796 {if (true) throw (ParseException)jjte000;} 1797 } 1798 {if (true) throw (Error)jjte000;} 1799 } finally { 1800 if (jjtc000) { 1801 jjtree.closeNodeScope(jjtn000, true); 1802 jjtreeCloseNodeScope(jjtn000); 1803 } 1804 } 1805 } 1806 1807 final public void Method() throws ParseException { 1808 /*@bgen(jjtree) MethodNode */ 1809 ASTMethodNode jjtn000 = new ASTMethodNode(JJTMETHODNODE); 1810 boolean jjtc000 = true; 1811 jjtree.openNodeScope(jjtn000); 1812 jjtreeOpenNodeScope(jjtn000); 1813 try { 1814 Identifier(); 1815 jj_consume_token(LPAREN); 1816 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1817 case NEW: 1818 case EMPTY: 1819 case SIZE: 1820 case NULL: 1821 case TRUE: 1822 case FALSE: 1823 case LPAREN: 1824 case LCURLY: 1825 case LBRACKET: 1826 case not: 1827 case minus: 1828 case tilda: 1829 case IDENTIFIER: 1830 case REGISTER: 1831 case INTEGER_LITERAL: 1832 case FLOAT_LITERAL: 1833 case STRING_LITERAL: 1834 Expression(); 1835 label_14: 1836 while (true) { 1837 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1838 case COMMA: 1839 ; 1840 break; 1841 default: 1842 jj_la1[32] = jj_gen; 1843 break label_14; 1844 } 1845 jj_consume_token(COMMA); 1846 Expression(); 1847 } 1848 break; 1849 default: 1850 jj_la1[33] = jj_gen; 1851 ; 1852 } 1853 jj_consume_token(RPAREN); 1854 } catch (Throwable jjte000) { 1855 if (jjtc000) { 1856 jjtree.clearNodeScope(jjtn000); 1857 jjtc000 = false; 1858 } else { 1859 jjtree.popNode(); 1860 } 1861 if (jjte000 instanceof RuntimeException) { 1862 {if (true) throw (RuntimeException)jjte000;} 1863 } 1864 if (jjte000 instanceof ParseException) { 1865 {if (true) throw (ParseException)jjte000;} 1866 } 1867 {if (true) throw (Error)jjte000;} 1868 } finally { 1869 if (jjtc000) { 1870 jjtree.closeNodeScope(jjtn000, true); 1871 jjtreeCloseNodeScope(jjtn000); 1872 } 1873 } 1874 } 1875 1876 final public void AnyMethod() throws ParseException { 1877 if (jj_2_5(2147483647)) { 1878 SizeMethod(); 1879 } else if (jj_2_6(2147483647)) { 1880 Method(); 1881 } else { 1882 jj_consume_token(-1); 1883 throw new ParseException(); 1884 } 1885 } 1886 1887 final public void SizeMethod() throws ParseException { 1888 /*@bgen(jjtree) SizeMethod */ 1889 ASTSizeMethod jjtn000 = new ASTSizeMethod(JJTSIZEMETHOD); 1890 boolean jjtc000 = true; 1891 jjtree.openNodeScope(jjtn000); 1892 jjtreeOpenNodeScope(jjtn000); 1893 try { 1894 jj_consume_token(SIZE); 1895 jj_consume_token(LPAREN); 1896 jj_consume_token(RPAREN); 1897 } finally { 1898 if (jjtc000) { 1899 jjtree.closeNodeScope(jjtn000, true); 1900 jjtreeCloseNodeScope(jjtn000); 1901 } 1902 } 1903 } 1904 1905 final public void Constructor() throws ParseException { 1906 /*@bgen(jjtree) #ConstructorNode(true) */ 1907 ASTConstructorNode jjtn000 = new ASTConstructorNode(JJTCONSTRUCTORNODE); 1908 boolean jjtc000 = true; 1909 jjtree.openNodeScope(jjtn000); 1910 jjtreeOpenNodeScope(jjtn000); 1911 try { 1912 jj_consume_token(NEW); 1913 jj_consume_token(LPAREN); 1914 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1915 case NEW: 1916 case EMPTY: 1917 case SIZE: 1918 case NULL: 1919 case TRUE: 1920 case FALSE: 1921 case LPAREN: 1922 case LCURLY: 1923 case LBRACKET: 1924 case not: 1925 case minus: 1926 case tilda: 1927 case IDENTIFIER: 1928 case REGISTER: 1929 case INTEGER_LITERAL: 1930 case FLOAT_LITERAL: 1931 case STRING_LITERAL: 1932 Expression(); 1933 label_15: 1934 while (true) { 1935 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1936 case COMMA: 1937 ; 1938 break; 1939 default: 1940 jj_la1[34] = jj_gen; 1941 break label_15; 1942 } 1943 jj_consume_token(COMMA); 1944 Expression(); 1945 } 1946 break; 1947 default: 1948 jj_la1[35] = jj_gen; 1949 ; 1950 } 1951 jj_consume_token(RPAREN); 1952 } catch (Throwable jjte000) { 1953 if (jjtc000) { 1954 jjtree.clearNodeScope(jjtn000); 1955 jjtc000 = false; 1956 } else { 1957 jjtree.popNode(); 1958 } 1959 if (jjte000 instanceof RuntimeException) { 1960 {if (true) throw (RuntimeException)jjte000;} 1961 } 1962 if (jjte000 instanceof ParseException) { 1963 {if (true) throw (ParseException)jjte000;} 1964 } 1965 {if (true) throw (Error)jjte000;} 1966 } finally { 1967 if (jjtc000) { 1968 jjtree.closeNodeScope(jjtn000, true); 1969 jjtreeCloseNodeScope(jjtn000); 1970 } 1971 } 1972 } 1973 1974 /*************************************** 1975 * References 1976 ***************************************/ 1977 final public void PrimaryExpression() throws ParseException { 1978 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1979 case NULL: 1980 case TRUE: 1981 case FALSE: 1982 case INTEGER_LITERAL: 1983 case FLOAT_LITERAL: 1984 case STRING_LITERAL: 1985 Literal(); 1986 break; 1987 default: 1988 jj_la1[36] = jj_gen; 1989 if (jj_2_7(3)) { 1990 Reference(); 1991 } else if (jj_2_8(2147483647)) { 1992 jj_consume_token(LPAREN); 1993 Expression(); 1994 jj_consume_token(RPAREN); 1995 } else if (jj_2_9(2147483647)) { 1996 EmptyFunction(); 1997 } else if (jj_2_10(2147483647)) { 1998 SizeFunction(); 1999 } else if (jj_2_11(2147483647)) { 2000 Constructor(); 2001 } else if (jj_2_12(2147483647)) { 2002 MapLiteral(); 2003 } else if (jj_2_13(2147483647)) { 2004 ArrayLiteral(); 2005 } else { 2006 jj_consume_token(-1); 2007 throw new ParseException(); 2008 } 2009 } 2010 } 2011 2012 final public void ArrayAccess() throws ParseException { 2013 /*@bgen(jjtree) ArrayAccess */ 2014 ASTArrayAccess jjtn000 = new ASTArrayAccess(JJTARRAYACCESS); 2015 boolean jjtc000 = true; 2016 jjtree.openNodeScope(jjtn000); 2017 jjtreeOpenNodeScope(jjtn000); 2018 try { 2019 Identifier(); 2020 label_16: 2021 while (true) { 2022 jj_consume_token(LBRACKET); 2023 Expression(); 2024 jj_consume_token(RBRACKET); 2025 if (jj_2_14(2)) { 2026 ; 2027 } else { 2028 break label_16; 2029 } 2030 } 2031 } catch (Throwable jjte000) { 2032 if (jjtc000) { 2033 jjtree.clearNodeScope(jjtn000); 2034 jjtc000 = false; 2035 } else { 2036 jjtree.popNode(); 2037 } 2038 if (jjte000 instanceof RuntimeException) { 2039 {if (true) throw (RuntimeException)jjte000;} 2040 } 2041 if (jjte000 instanceof ParseException) { 2042 {if (true) throw (ParseException)jjte000;} 2043 } 2044 {if (true) throw (Error)jjte000;} 2045 } finally { 2046 if (jjtc000) { 2047 jjtree.closeNodeScope(jjtn000, true); 2048 jjtreeCloseNodeScope(jjtn000); 2049 } 2050 } 2051 } 2052 2053 final public void DotReference() throws ParseException { 2054 label_17: 2055 while (true) { 2056 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2057 case DOT: 2058 ; 2059 break; 2060 default: 2061 jj_la1[37] = jj_gen; 2062 break label_17; 2063 } 2064 jj_consume_token(DOT); 2065 if (jj_2_16(2147483647)) { 2066 ArrayAccess(); 2067 } else { 2068 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2069 case SIZE: 2070 case IDENTIFIER: 2071 case REGISTER: 2072 case INTEGER_LITERAL: 2073 if (jj_2_15(3)) { 2074 AnyMethod(); 2075 } else { 2076 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2077 case IDENTIFIER: 2078 case REGISTER: 2079 Identifier(); 2080 break; 2081 case INTEGER_LITERAL: 2082 IntegerLiteral(); 2083 break; 2084 default: 2085 jj_la1[38] = jj_gen; 2086 jj_consume_token(-1); 2087 throw new ParseException(); 2088 } 2089 } 2090 break; 2091 default: 2092 jj_la1[39] = jj_gen; 2093 jj_consume_token(-1); 2094 throw new ParseException(); 2095 } 2096 } 2097 } 2098 } 2099 2100 final public void Reference() throws ParseException { 2101 /*@bgen(jjtree) Reference */ 2102 ASTReference jjtn000 = new ASTReference(JJTREFERENCE); 2103 boolean jjtc000 = true; 2104 jjtree.openNodeScope(jjtn000); 2105 jjtreeOpenNodeScope(jjtn000); 2106 try { 2107 if (jj_2_17(2147483647)) { 2108 Constructor(); 2109 } else if (jj_2_18(2147483647)) { 2110 ArrayAccess(); 2111 } else if (jj_2_19(2147483647)) { 2112 Function(); 2113 } else if (jj_2_20(2147483647)) { 2114 Method(); 2115 } else { 2116 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2117 case IDENTIFIER: 2118 case REGISTER: 2119 Identifier(); 2120 break; 2121 default: 2122 jj_la1[40] = jj_gen; 2123 if (jj_2_21(2147483647)) { 2124 MapLiteral(); 2125 } else if (jj_2_22(2147483647)) { 2126 ArrayLiteral(); 2127 } else { 2128 jj_consume_token(-1); 2129 throw new ParseException(); 2130 } 2131 } 2132 } 2133 DotReference(); 2134 } catch (Throwable jjte000) { 2135 if (jjtc000) { 2136 jjtree.clearNodeScope(jjtn000); 2137 jjtc000 = false; 2138 } else { 2139 jjtree.popNode(); 2140 } 2141 if (jjte000 instanceof RuntimeException) { 2142 {if (true) throw (RuntimeException)jjte000;} 2143 } 2144 if (jjte000 instanceof ParseException) { 2145 {if (true) throw (ParseException)jjte000;} 2146 } 2147 {if (true) throw (Error)jjte000;} 2148 } finally { 2149 if (jjtc000) { 2150 jjtree.closeNodeScope(jjtn000, true); 2151 jjtreeCloseNodeScope(jjtn000); 2152 } 2153 } 2154 } 2155 2156 private boolean jj_2_1(int xla) { 2157 jj_la = xla; jj_lastpos = jj_scanpos = token; 2158 try { return !jj_3_1(); } 2159 catch(LookaheadSuccess ls) { return true; } 2160 finally { jj_save(0, xla); } 2161 } 2162 2163 private boolean jj_2_2(int xla) { 2164 jj_la = xla; jj_lastpos = jj_scanpos = token; 2165 try { return !jj_3_2(); } 2166 catch(LookaheadSuccess ls) { return true; } 2167 finally { jj_save(1, xla); } 2168 } 2169 2170 private boolean jj_2_3(int xla) { 2171 jj_la = xla; jj_lastpos = jj_scanpos = token; 2172 try { return !jj_3_3(); } 2173 catch(LookaheadSuccess ls) { return true; } 2174 finally { jj_save(2, xla); } 2175 } 2176 2177 private boolean jj_2_4(int xla) { 2178 jj_la = xla; jj_lastpos = jj_scanpos = token; 2179 try { return !jj_3_4(); } 2180 catch(LookaheadSuccess ls) { return true; } 2181 finally { jj_save(3, xla); } 2182 } 2183 2184 private boolean jj_2_5(int xla) { 2185 jj_la = xla; jj_lastpos = jj_scanpos = token; 2186 try { return !jj_3_5(); } 2187 catch(LookaheadSuccess ls) { return true; } 2188 finally { jj_save(4, xla); } 2189 } 2190 2191 private boolean jj_2_6(int xla) { 2192 jj_la = xla; jj_lastpos = jj_scanpos = token; 2193 try { return !jj_3_6(); } 2194 catch(LookaheadSuccess ls) { return true; } 2195 finally { jj_save(5, xla); } 2196 } 2197 2198 private boolean jj_2_7(int xla) { 2199 jj_la = xla; jj_lastpos = jj_scanpos = token; 2200 try { return !jj_3_7(); } 2201 catch(LookaheadSuccess ls) { return true; } 2202 finally { jj_save(6, xla); } 2203 } 2204 2205 private boolean jj_2_8(int xla) { 2206 jj_la = xla; jj_lastpos = jj_scanpos = token; 2207 try { return !jj_3_8(); } 2208 catch(LookaheadSuccess ls) { return true; } 2209 finally { jj_save(7, xla); } 2210 } 2211 2212 private boolean jj_2_9(int xla) { 2213 jj_la = xla; jj_lastpos = jj_scanpos = token; 2214 try { return !jj_3_9(); } 2215 catch(LookaheadSuccess ls) { return true; } 2216 finally { jj_save(8, xla); } 2217 } 2218 2219 private boolean jj_2_10(int xla) { 2220 jj_la = xla; jj_lastpos = jj_scanpos = token; 2221 try { return !jj_3_10(); } 2222 catch(LookaheadSuccess ls) { return true; } 2223 finally { jj_save(9, xla); } 2224 } 2225 2226 private boolean jj_2_11(int xla) { 2227 jj_la = xla; jj_lastpos = jj_scanpos = token; 2228 try { return !jj_3_11(); } 2229 catch(LookaheadSuccess ls) { return true; } 2230 finally { jj_save(10, xla); } 2231 } 2232 2233 private boolean jj_2_12(int xla) { 2234 jj_la = xla; jj_lastpos = jj_scanpos = token; 2235 try { return !jj_3_12(); } 2236 catch(LookaheadSuccess ls) { return true; } 2237 finally { jj_save(11, xla); } 2238 } 2239 2240 private boolean jj_2_13(int xla) { 2241 jj_la = xla; jj_lastpos = jj_scanpos = token; 2242 try { return !jj_3_13(); } 2243 catch(LookaheadSuccess ls) { return true; } 2244 finally { jj_save(12, xla); } 2245 } 2246 2247 private boolean jj_2_14(int xla) { 2248 jj_la = xla; jj_lastpos = jj_scanpos = token; 2249 try { return !jj_3_14(); } 2250 catch(LookaheadSuccess ls) { return true; } 2251 finally { jj_save(13, xla); } 2252 } 2253 2254 private boolean jj_2_15(int xla) { 2255 jj_la = xla; jj_lastpos = jj_scanpos = token; 2256 try { return !jj_3_15(); } 2257 catch(LookaheadSuccess ls) { return true; } 2258 finally { jj_save(14, xla); } 2259 } 2260 2261 private boolean jj_2_16(int xla) { 2262 jj_la = xla; jj_lastpos = jj_scanpos = token; 2263 try { return !jj_3_16(); } 2264 catch(LookaheadSuccess ls) { return true; } 2265 finally { jj_save(15, xla); } 2266 } 2267 2268 private boolean jj_2_17(int xla) { 2269 jj_la = xla; jj_lastpos = jj_scanpos = token; 2270 try { return !jj_3_17(); } 2271 catch(LookaheadSuccess ls) { return true; } 2272 finally { jj_save(16, xla); } 2273 } 2274 2275 private boolean jj_2_18(int xla) { 2276 jj_la = xla; jj_lastpos = jj_scanpos = token; 2277 try { return !jj_3_18(); } 2278 catch(LookaheadSuccess ls) { return true; } 2279 finally { jj_save(17, xla); } 2280 } 2281 2282 private boolean jj_2_19(int xla) { 2283 jj_la = xla; jj_lastpos = jj_scanpos = token; 2284 try { return !jj_3_19(); } 2285 catch(LookaheadSuccess ls) { return true; } 2286 finally { jj_save(18, xla); } 2287 } 2288 2289 private boolean jj_2_20(int xla) { 2290 jj_la = xla; jj_lastpos = jj_scanpos = token; 2291 try { return !jj_3_20(); } 2292 catch(LookaheadSuccess ls) { return true; } 2293 finally { jj_save(19, xla); } 2294 } 2295 2296 private boolean jj_2_21(int xla) { 2297 jj_la = xla; jj_lastpos = jj_scanpos = token; 2298 try { return !jj_3_21(); } 2299 catch(LookaheadSuccess ls) { return true; } 2300 finally { jj_save(20, xla); } 2301 } 2302 2303 private boolean jj_2_22(int xla) { 2304 jj_la = xla; jj_lastpos = jj_scanpos = token; 2305 try { return !jj_3_22(); } 2306 catch(LookaheadSuccess ls) { return true; } 2307 finally { jj_save(21, xla); } 2308 } 2309 2310 private boolean jj_3R_109() { 2311 if (jj_scan_token(mult)) return true; 2312 if (jj_3R_102()) return true; 2313 return false; 2314 } 2315 2316 private boolean jj_3R_103() { 2317 Token xsp; 2318 xsp = jj_scanpos; 2319 if (jj_3R_109()) { 2320 jj_scanpos = xsp; 2321 if (jj_3R_110()) { 2322 jj_scanpos = xsp; 2323 if (jj_3R_111()) return true; 2324 } 2325 } 2326 return false; 2327 } 2328 2329 private boolean jj_3_14() { 2330 if (jj_scan_token(LBRACKET)) return true; 2331 if (jj_3R_20()) return true; 2332 if (jj_scan_token(RBRACKET)) return true; 2333 return false; 2334 } 2335 2336 private boolean jj_3_15() { 2337 if (jj_3R_23()) return true; 2338 return false; 2339 } 2340 2341 private boolean jj_3R_60() { 2342 Token xsp; 2343 xsp = jj_scanpos; 2344 if (jj_3_15()) { 2345 jj_scanpos = xsp; 2346 if (jj_3R_70()) { 2347 jj_scanpos = xsp; 2348 if (jj_3R_71()) return true; 2349 } 2350 } 2351 return false; 2352 } 2353 2354 private boolean jj_3R_94() { 2355 if (jj_3R_102()) return true; 2356 Token xsp; 2357 while (true) { 2358 xsp = jj_scanpos; 2359 if (jj_3R_103()) { jj_scanpos = xsp; break; } 2360 } 2361 return false; 2362 } 2363 2364 private boolean jj_3R_59() { 2365 if (jj_3R_41()) return true; 2366 return false; 2367 } 2368 2369 private boolean jj_3R_113() { 2370 if (jj_scan_token(minus)) return true; 2371 return false; 2372 } 2373 2374 private boolean jj_3R_68() { 2375 if (jj_scan_token(COMMA)) return true; 2376 if (jj_3R_20()) return true; 2377 return false; 2378 } 2379 2380 private boolean jj_3R_112() { 2381 if (jj_scan_token(plus)) return true; 2382 return false; 2383 } 2384 2385 private boolean jj_3R_104() { 2386 Token xsp; 2387 xsp = jj_scanpos; 2388 if (jj_3R_112()) { 2389 jj_scanpos = xsp; 2390 if (jj_3R_113()) return true; 2391 } 2392 return false; 2393 } 2394 2395 private boolean jj_3R_46() { 2396 if (jj_scan_token(DOT)) return true; 2397 Token xsp; 2398 xsp = jj_scanpos; 2399 if (jj_3R_59()) { 2400 jj_scanpos = xsp; 2401 if (jj_3R_60()) return true; 2402 } 2403 return false; 2404 } 2405 2406 private boolean jj_3_13() { 2407 if (jj_scan_token(LBRACKET)) return true; 2408 if (jj_3R_20()) return true; 2409 return false; 2410 } 2411 2412 private boolean jj_3R_32() { 2413 Token xsp; 2414 while (true) { 2415 xsp = jj_scanpos; 2416 if (jj_3R_46()) { jj_scanpos = xsp; break; } 2417 } 2418 return false; 2419 } 2420 2421 private boolean jj_3_12() { 2422 if (jj_scan_token(LCURLY)) return true; 2423 if (jj_3R_22()) return true; 2424 return false; 2425 } 2426 2427 private boolean jj_3R_90() { 2428 if (jj_3R_94()) return true; 2429 Token xsp; 2430 while (true) { 2431 xsp = jj_scanpos; 2432 if (jj_3R_95()) { jj_scanpos = xsp; break; } 2433 } 2434 return false; 2435 } 2436 2437 private boolean jj_3R_41() { 2438 if (jj_3R_21()) return true; 2439 Token xsp; 2440 if (jj_3_14()) return true; 2441 while (true) { 2442 xsp = jj_scanpos; 2443 if (jj_3_14()) { jj_scanpos = xsp; break; } 2444 } 2445 return false; 2446 } 2447 2448 private boolean jj_3R_67() { 2449 if (jj_scan_token(COMMA)) return true; 2450 if (jj_3R_20()) return true; 2451 return false; 2452 } 2453 2454 private boolean jj_3_11() { 2455 if (jj_scan_token(NEW)) return true; 2456 if (jj_scan_token(LPAREN)) return true; 2457 return false; 2458 } 2459 2460 private boolean jj_3_10() { 2461 if (jj_scan_token(SIZE)) return true; 2462 return false; 2463 } 2464 2465 private boolean jj_3_9() { 2466 if (jj_scan_token(EMPTY)) return true; 2467 return false; 2468 } 2469 2470 private boolean jj_3_8() { 2471 if (jj_scan_token(LPAREN)) return true; 2472 return false; 2473 } 2474 2475 private boolean jj_3R_121() { 2476 if (jj_3R_45()) return true; 2477 return false; 2478 } 2479 2480 private boolean jj_3R_55() { 2481 if (jj_3R_20()) return true; 2482 Token xsp; 2483 while (true) { 2484 xsp = jj_scanpos; 2485 if (jj_3R_68()) { jj_scanpos = xsp; break; } 2486 } 2487 return false; 2488 } 2489 2490 private boolean jj_3R_120() { 2491 if (jj_3R_44()) return true; 2492 return false; 2493 } 2494 2495 private boolean jj_3R_101() { 2496 if (jj_scan_token(rne)) return true; 2497 if (jj_3R_90()) return true; 2498 return false; 2499 } 2500 2501 private boolean jj_3R_69() { 2502 if (jj_scan_token(COMMA)) return true; 2503 if (jj_3R_20()) return true; 2504 return false; 2505 } 2506 2507 private boolean jj_3R_119() { 2508 if (jj_3R_40()) return true; 2509 return false; 2510 } 2511 2512 private boolean jj_3R_100() { 2513 if (jj_scan_token(req)) return true; 2514 if (jj_3R_90()) return true; 2515 return false; 2516 } 2517 2518 private boolean jj_3R_118() { 2519 if (jj_3R_124()) return true; 2520 return false; 2521 } 2522 2523 private boolean jj_3R_99() { 2524 if (jj_scan_token(ge)) return true; 2525 if (jj_3R_90()) return true; 2526 return false; 2527 } 2528 2529 private boolean jj_3R_117() { 2530 if (jj_3R_123()) return true; 2531 return false; 2532 } 2533 2534 private boolean jj_3R_98() { 2535 if (jj_scan_token(le)) return true; 2536 if (jj_3R_90()) return true; 2537 return false; 2538 } 2539 2540 private boolean jj_3R_54() { 2541 if (jj_3R_20()) return true; 2542 Token xsp; 2543 while (true) { 2544 xsp = jj_scanpos; 2545 if (jj_3R_67()) { jj_scanpos = xsp; break; } 2546 } 2547 return false; 2548 } 2549 2550 private boolean jj_3R_116() { 2551 if (jj_scan_token(LPAREN)) return true; 2552 if (jj_3R_20()) return true; 2553 if (jj_scan_token(RPAREN)) return true; 2554 return false; 2555 } 2556 2557 private boolean jj_3R_97() { 2558 if (jj_scan_token(gt)) return true; 2559 if (jj_3R_90()) return true; 2560 return false; 2561 } 2562 2563 private boolean jj_3R_96() { 2564 if (jj_scan_token(lt)) return true; 2565 if (jj_3R_90()) return true; 2566 return false; 2567 } 2568 2569 private boolean jj_3R_91() { 2570 Token xsp; 2571 xsp = jj_scanpos; 2572 if (jj_3R_96()) { 2573 jj_scanpos = xsp; 2574 if (jj_3R_97()) { 2575 jj_scanpos = xsp; 2576 if (jj_3R_98()) { 2577 jj_scanpos = xsp; 2578 if (jj_3R_99()) { 2579 jj_scanpos = xsp; 2580 if (jj_3R_100()) { 2581 jj_scanpos = xsp; 2582 if (jj_3R_101()) return true; 2583 } 2584 } 2585 } 2586 } 2587 } 2588 return false; 2589 } 2590 2591 private boolean jj_3_7() { 2592 if (jj_3R_19()) return true; 2593 return false; 2594 } 2595 2596 private boolean jj_3R_115() { 2597 if (jj_3R_122()) return true; 2598 return false; 2599 } 2600 2601 private boolean jj_3R_114() { 2602 Token xsp; 2603 xsp = jj_scanpos; 2604 if (jj_3R_115()) { 2605 jj_scanpos = xsp; 2606 if (jj_3_7()) { 2607 jj_scanpos = xsp; 2608 if (jj_3R_116()) { 2609 jj_scanpos = xsp; 2610 if (jj_3R_117()) { 2611 jj_scanpos = xsp; 2612 if (jj_3R_118()) { 2613 jj_scanpos = xsp; 2614 if (jj_3R_119()) { 2615 jj_scanpos = xsp; 2616 if (jj_3R_120()) { 2617 jj_scanpos = xsp; 2618 if (jj_3R_121()) return true; 2619 } 2620 } 2621 } 2622 } 2623 } 2624 } 2625 } 2626 return false; 2627 } 2628 2629 private boolean jj_3R_88() { 2630 if (jj_3R_90()) return true; 2631 Token xsp; 2632 xsp = jj_scanpos; 2633 if (jj_3R_91()) jj_scanpos = xsp; 2634 return false; 2635 } 2636 2637 private boolean jj_3R_56() { 2638 if (jj_3R_20()) return true; 2639 Token xsp; 2640 while (true) { 2641 xsp = jj_scanpos; 2642 if (jj_3R_69()) { jj_scanpos = xsp; break; } 2643 } 2644 return false; 2645 } 2646 2647 private boolean jj_3R_93() { 2648 if (jj_scan_token(ne)) return true; 2649 if (jj_3R_88()) return true; 2650 return false; 2651 } 2652 2653 private boolean jj_3R_92() { 2654 if (jj_scan_token(eq)) return true; 2655 if (jj_3R_88()) return true; 2656 return false; 2657 } 2658 2659 private boolean jj_3R_89() { 2660 Token xsp; 2661 xsp = jj_scanpos; 2662 if (jj_3R_92()) { 2663 jj_scanpos = xsp; 2664 if (jj_3R_93()) return true; 2665 } 2666 return false; 2667 } 2668 2669 private boolean jj_3_6() { 2670 if (jj_3R_21()) return true; 2671 if (jj_scan_token(LPAREN)) return true; 2672 return false; 2673 } 2674 2675 private boolean jj_3_5() { 2676 if (jj_scan_token(SIZE)) return true; 2677 return false; 2678 } 2679 2680 private boolean jj_3R_40() { 2681 if (jj_scan_token(NEW)) return true; 2682 if (jj_scan_token(LPAREN)) return true; 2683 Token xsp; 2684 xsp = jj_scanpos; 2685 if (jj_3R_54()) jj_scanpos = xsp; 2686 if (jj_scan_token(RPAREN)) return true; 2687 return false; 2688 } 2689 2690 private boolean jj_3R_86() { 2691 if (jj_3R_88()) return true; 2692 Token xsp; 2693 xsp = jj_scanpos; 2694 if (jj_3R_89()) jj_scanpos = xsp; 2695 return false; 2696 } 2697 2698 private boolean jj_3R_49() { 2699 if (jj_scan_token(SIZE)) return true; 2700 if (jj_scan_token(LPAREN)) return true; 2701 if (jj_scan_token(RPAREN)) return true; 2702 return false; 2703 } 2704 2705 private boolean jj_3R_87() { 2706 if (jj_scan_token(and)) return true; 2707 if (jj_3R_86()) return true; 2708 return false; 2709 } 2710 2711 private boolean jj_3R_38() { 2712 if (jj_3R_43()) return true; 2713 return false; 2714 } 2715 2716 private boolean jj_3R_84() { 2717 if (jj_3R_86()) return true; 2718 Token xsp; 2719 while (true) { 2720 xsp = jj_scanpos; 2721 if (jj_3R_87()) { jj_scanpos = xsp; break; } 2722 } 2723 return false; 2724 } 2725 2726 private boolean jj_3R_23() { 2727 Token xsp; 2728 xsp = jj_scanpos; 2729 if (jj_3R_37()) { 2730 jj_scanpos = xsp; 2731 if (jj_3R_38()) return true; 2732 } 2733 return false; 2734 } 2735 2736 private boolean jj_3R_37() { 2737 if (jj_3R_49()) return true; 2738 return false; 2739 } 2740 2741 private boolean jj_3R_85() { 2742 if (jj_scan_token(xor)) return true; 2743 if (jj_3R_84()) return true; 2744 return false; 2745 } 2746 2747 private boolean jj_3R_43() { 2748 if (jj_3R_21()) return true; 2749 if (jj_scan_token(LPAREN)) return true; 2750 Token xsp; 2751 xsp = jj_scanpos; 2752 if (jj_3R_56()) jj_scanpos = xsp; 2753 if (jj_scan_token(RPAREN)) return true; 2754 return false; 2755 } 2756 2757 private boolean jj_3R_82() { 2758 if (jj_3R_84()) return true; 2759 Token xsp; 2760 while (true) { 2761 xsp = jj_scanpos; 2762 if (jj_3R_85()) { jj_scanpos = xsp; break; } 2763 } 2764 return false; 2765 } 2766 2767 private boolean jj_3R_83() { 2768 if (jj_scan_token(or)) return true; 2769 if (jj_3R_82()) return true; 2770 return false; 2771 } 2772 2773 private boolean jj_3R_42() { 2774 if (jj_3R_21()) return true; 2775 if (jj_scan_token(COLON)) return true; 2776 if (jj_3R_21()) return true; 2777 if (jj_scan_token(LPAREN)) return true; 2778 Token xsp; 2779 xsp = jj_scanpos; 2780 if (jj_3R_55()) jj_scanpos = xsp; 2781 if (jj_scan_token(RPAREN)) return true; 2782 return false; 2783 } 2784 2785 private boolean jj_3R_80() { 2786 if (jj_3R_82()) return true; 2787 Token xsp; 2788 while (true) { 2789 xsp = jj_scanpos; 2790 if (jj_3R_83()) { jj_scanpos = xsp; break; } 2791 } 2792 return false; 2793 } 2794 2795 private boolean jj_3R_57() { 2796 if (jj_scan_token(COMMA)) return true; 2797 if (jj_3R_22()) return true; 2798 return false; 2799 } 2800 2801 private boolean jj_3R_124() { 2802 if (jj_scan_token(SIZE)) return true; 2803 if (jj_scan_token(LPAREN)) return true; 2804 if (jj_3R_20()) return true; 2805 if (jj_scan_token(RPAREN)) return true; 2806 return false; 2807 } 2808 2809 private boolean jj_3R_81() { 2810 if (jj_scan_token(AND)) return true; 2811 if (jj_3R_80()) return true; 2812 return false; 2813 } 2814 2815 private boolean jj_3R_58() { 2816 if (jj_scan_token(COMMA)) return true; 2817 if (jj_3R_20()) return true; 2818 return false; 2819 } 2820 2821 private boolean jj_3R_130() { 2822 if (jj_scan_token(EMPTY)) return true; 2823 if (jj_3R_19()) return true; 2824 return false; 2825 } 2826 2827 private boolean jj_3R_123() { 2828 Token xsp; 2829 xsp = jj_scanpos; 2830 if (jj_3_4()) { 2831 jj_scanpos = xsp; 2832 if (jj_3R_130()) return true; 2833 } 2834 return false; 2835 } 2836 2837 private boolean jj_3R_72() { 2838 if (jj_3R_80()) return true; 2839 Token xsp; 2840 while (true) { 2841 xsp = jj_scanpos; 2842 if (jj_3R_81()) { jj_scanpos = xsp; break; } 2843 } 2844 return false; 2845 } 2846 2847 private boolean jj_3_4() { 2848 if (jj_scan_token(EMPTY)) return true; 2849 if (jj_scan_token(LPAREN)) return true; 2850 if (jj_3R_20()) return true; 2851 if (jj_scan_token(RPAREN)) return true; 2852 return false; 2853 } 2854 2855 private boolean jj_3R_73() { 2856 if (jj_scan_token(OR)) return true; 2857 if (jj_3R_72()) return true; 2858 return false; 2859 } 2860 2861 private boolean jj_3_2() { 2862 if (jj_scan_token(SEMICOL)) return true; 2863 return false; 2864 } 2865 2866 private boolean jj_3R_61() { 2867 if (jj_3R_72()) return true; 2868 Token xsp; 2869 while (true) { 2870 xsp = jj_scanpos; 2871 if (jj_3R_73()) { jj_scanpos = xsp; break; } 2872 } 2873 return false; 2874 } 2875 2876 private boolean jj_3R_22() { 2877 if (jj_3R_20()) return true; 2878 if (jj_scan_token(COLON)) return true; 2879 if (jj_3R_20()) return true; 2880 return false; 2881 } 2882 2883 private boolean jj_3R_75() { 2884 if (jj_scan_token(ELVIS)) return true; 2885 if (jj_3R_20()) return true; 2886 return false; 2887 } 2888 2889 private boolean jj_3R_44() { 2890 if (jj_scan_token(LCURLY)) return true; 2891 if (jj_3R_22()) return true; 2892 Token xsp; 2893 while (true) { 2894 xsp = jj_scanpos; 2895 if (jj_3R_57()) { jj_scanpos = xsp; break; } 2896 } 2897 if (jj_scan_token(RCURLY)) return true; 2898 return false; 2899 } 2900 2901 private boolean jj_3R_74() { 2902 if (jj_scan_token(QMARK)) return true; 2903 if (jj_3R_20()) return true; 2904 if (jj_scan_token(COLON)) return true; 2905 if (jj_3R_20()) return true; 2906 return false; 2907 } 2908 2909 private boolean jj_3R_62() { 2910 Token xsp; 2911 xsp = jj_scanpos; 2912 if (jj_3R_74()) { 2913 jj_scanpos = xsp; 2914 if (jj_3R_75()) return true; 2915 } 2916 return false; 2917 } 2918 2919 private boolean jj_3R_48() { 2920 if (jj_3R_61()) return true; 2921 Token xsp; 2922 xsp = jj_scanpos; 2923 if (jj_3R_62()) jj_scanpos = xsp; 2924 return false; 2925 } 2926 2927 private boolean jj_3R_45() { 2928 if (jj_scan_token(LBRACKET)) return true; 2929 if (jj_3R_20()) return true; 2930 Token xsp; 2931 while (true) { 2932 xsp = jj_scanpos; 2933 if (jj_3R_58()) { jj_scanpos = xsp; break; } 2934 } 2935 if (jj_scan_token(RBRACKET)) return true; 2936 return false; 2937 } 2938 2939 private boolean jj_3_3() { 2940 if (jj_3R_19()) return true; 2941 if (jj_scan_token(assign)) return true; 2942 return false; 2943 } 2944 2945 private boolean jj_3R_47() { 2946 if (jj_3R_19()) return true; 2947 if (jj_scan_token(assign)) return true; 2948 if (jj_3R_20()) return true; 2949 return false; 2950 } 2951 2952 private boolean jj_3R_133() { 2953 if (jj_scan_token(STRING_LITERAL)) return true; 2954 return false; 2955 } 2956 2957 private boolean jj_3R_34() { 2958 if (jj_3R_48()) return true; 2959 return false; 2960 } 2961 2962 private boolean jj_3R_20() { 2963 Token xsp; 2964 xsp = jj_scanpos; 2965 if (jj_3R_33()) { 2966 jj_scanpos = xsp; 2967 if (jj_3R_34()) return true; 2968 } 2969 return false; 2970 } 2971 2972 private boolean jj_3R_33() { 2973 if (jj_3R_47()) return true; 2974 return false; 2975 } 2976 2977 private boolean jj_3R_131() { 2978 if (jj_scan_token(FLOAT_LITERAL)) return true; 2979 return false; 2980 } 2981 2982 private boolean jj_3R_77() { 2983 if (jj_scan_token(FOREACH)) return true; 2984 if (jj_scan_token(LPAREN)) return true; 2985 return false; 2986 } 2987 2988 private boolean jj_3R_79() { 2989 if (jj_scan_token(INTEGER_LITERAL)) return true; 2990 return false; 2991 } 2992 2993 private boolean jj_3R_76() { 2994 if (jj_scan_token(FOR)) return true; 2995 if (jj_scan_token(LPAREN)) return true; 2996 return false; 2997 } 2998 2999 private boolean jj_3R_64() { 3000 Token xsp; 3001 xsp = jj_scanpos; 3002 if (jj_3R_76()) { 3003 jj_scanpos = xsp; 3004 if (jj_3R_77()) return true; 3005 } 3006 return false; 3007 } 3008 3009 private boolean jj_3R_78() { 3010 if (jj_3R_20()) return true; 3011 return false; 3012 } 3013 3014 private boolean jj_3R_65() { 3015 if (jj_scan_token(WHILE)) return true; 3016 if (jj_scan_token(LPAREN)) return true; 3017 return false; 3018 } 3019 3020 private boolean jj_3R_136() { 3021 if (jj_scan_token(FALSE)) return true; 3022 return false; 3023 } 3024 3025 private boolean jj_3R_135() { 3026 if (jj_scan_token(TRUE)) return true; 3027 return false; 3028 } 3029 3030 private boolean jj_3R_132() { 3031 Token xsp; 3032 xsp = jj_scanpos; 3033 if (jj_3R_135()) { 3034 jj_scanpos = xsp; 3035 if (jj_3R_136()) return true; 3036 } 3037 return false; 3038 } 3039 3040 private boolean jj_3R_63() { 3041 if (jj_scan_token(IF)) return true; 3042 if (jj_scan_token(LPAREN)) return true; 3043 return false; 3044 } 3045 3046 private boolean jj_3R_134() { 3047 if (jj_scan_token(NULL)) return true; 3048 return false; 3049 } 3050 3051 private boolean jj_3R_24() { 3052 if (jj_3R_39()) return true; 3053 return false; 3054 } 3055 3056 private boolean jj_3R_66() { 3057 if (jj_3R_20()) return true; 3058 Token xsp; 3059 while (true) { 3060 xsp = jj_scanpos; 3061 if (jj_3R_78()) { jj_scanpos = xsp; break; } 3062 } 3063 xsp = jj_scanpos; 3064 if (jj_3_2()) jj_scanpos = xsp; 3065 return false; 3066 } 3067 3068 private boolean jj_3R_129() { 3069 if (jj_3R_134()) return true; 3070 return false; 3071 } 3072 3073 private boolean jj_3R_128() { 3074 if (jj_3R_133()) return true; 3075 return false; 3076 } 3077 3078 private boolean jj_3R_127() { 3079 if (jj_3R_132()) return true; 3080 return false; 3081 } 3082 3083 private boolean jj_3R_18() { 3084 if (jj_scan_token(LCURLY)) return true; 3085 Token xsp; 3086 while (true) { 3087 xsp = jj_scanpos; 3088 if (jj_3R_24()) { jj_scanpos = xsp; break; } 3089 } 3090 if (jj_scan_token(RCURLY)) return true; 3091 return false; 3092 } 3093 3094 private boolean jj_3R_126() { 3095 if (jj_3R_131()) return true; 3096 return false; 3097 } 3098 3099 private boolean jj_3R_53() { 3100 if (jj_3R_66()) return true; 3101 return false; 3102 } 3103 3104 private boolean jj_3R_125() { 3105 if (jj_3R_79()) return true; 3106 return false; 3107 } 3108 3109 private boolean jj_3R_122() { 3110 Token xsp; 3111 xsp = jj_scanpos; 3112 if (jj_3R_125()) { 3113 jj_scanpos = xsp; 3114 if (jj_3R_126()) { 3115 jj_scanpos = xsp; 3116 if (jj_3R_127()) { 3117 jj_scanpos = xsp; 3118 if (jj_3R_128()) { 3119 jj_scanpos = xsp; 3120 if (jj_3R_129()) return true; 3121 } 3122 } 3123 } 3124 } 3125 return false; 3126 } 3127 3128 private boolean jj_3R_52() { 3129 if (jj_3R_65()) return true; 3130 return false; 3131 } 3132 3133 private boolean jj_3R_51() { 3134 if (jj_3R_64()) return true; 3135 return false; 3136 } 3137 3138 private boolean jj_3R_50() { 3139 if (jj_3R_63()) return true; 3140 return false; 3141 } 3142 3143 private boolean jj_3_1() { 3144 if (jj_3R_18()) return true; 3145 return false; 3146 } 3147 3148 private boolean jj_3R_39() { 3149 Token xsp; 3150 xsp = jj_scanpos; 3151 if (jj_scan_token(27)) { 3152 jj_scanpos = xsp; 3153 if (jj_3_1()) { 3154 jj_scanpos = xsp; 3155 if (jj_3R_50()) { 3156 jj_scanpos = xsp; 3157 if (jj_3R_51()) { 3158 jj_scanpos = xsp; 3159 if (jj_3R_52()) { 3160 jj_scanpos = xsp; 3161 if (jj_3R_53()) return true; 3162 } 3163 } 3164 } 3165 } 3166 } 3167 return false; 3168 } 3169 3170 private boolean jj_3R_36() { 3171 if (jj_scan_token(REGISTER)) return true; 3172 return false; 3173 } 3174 3175 private boolean jj_3R_21() { 3176 Token xsp; 3177 xsp = jj_scanpos; 3178 if (jj_3R_35()) { 3179 jj_scanpos = xsp; 3180 if (jj_3R_36()) return true; 3181 } 3182 return false; 3183 } 3184 3185 private boolean jj_3R_35() { 3186 if (jj_scan_token(IDENTIFIER)) return true; 3187 return false; 3188 } 3189 3190 private boolean jj_3_22() { 3191 if (jj_scan_token(LBRACKET)) return true; 3192 return false; 3193 } 3194 3195 private boolean jj_3_21() { 3196 if (jj_scan_token(LCURLY)) return true; 3197 return false; 3198 } 3199 3200 private boolean jj_3_20() { 3201 if (jj_3R_21()) return true; 3202 if (jj_scan_token(LPAREN)) return true; 3203 return false; 3204 } 3205 3206 private boolean jj_3_19() { 3207 if (jj_3R_21()) return true; 3208 if (jj_scan_token(COLON)) return true; 3209 if (jj_3R_21()) return true; 3210 if (jj_scan_token(LPAREN)) return true; 3211 return false; 3212 } 3213 3214 private boolean jj_3_18() { 3215 if (jj_3R_21()) return true; 3216 if (jj_scan_token(LBRACKET)) return true; 3217 return false; 3218 } 3219 3220 private boolean jj_3R_31() { 3221 if (jj_3R_45()) return true; 3222 return false; 3223 } 3224 3225 private boolean jj_3_17() { 3226 if (jj_scan_token(NEW)) return true; 3227 return false; 3228 } 3229 3230 private boolean jj_3R_30() { 3231 if (jj_3R_44()) return true; 3232 return false; 3233 } 3234 3235 private boolean jj_3R_95() { 3236 if (jj_3R_104()) return true; 3237 if (jj_3R_94()) return true; 3238 return false; 3239 } 3240 3241 private boolean jj_3R_29() { 3242 if (jj_3R_21()) return true; 3243 return false; 3244 } 3245 3246 private boolean jj_3R_108() { 3247 if (jj_3R_114()) return true; 3248 return false; 3249 } 3250 3251 private boolean jj_3R_28() { 3252 if (jj_3R_43()) return true; 3253 return false; 3254 } 3255 3256 private boolean jj_3R_107() { 3257 if (jj_scan_token(not)) return true; 3258 if (jj_3R_102()) return true; 3259 return false; 3260 } 3261 3262 private boolean jj_3R_27() { 3263 if (jj_3R_42()) return true; 3264 return false; 3265 } 3266 3267 private boolean jj_3R_106() { 3268 if (jj_scan_token(tilda)) return true; 3269 if (jj_3R_102()) return true; 3270 return false; 3271 } 3272 3273 private boolean jj_3R_26() { 3274 if (jj_3R_41()) return true; 3275 return false; 3276 } 3277 3278 private boolean jj_3R_105() { 3279 if (jj_scan_token(minus)) return true; 3280 if (jj_3R_102()) return true; 3281 return false; 3282 } 3283 3284 private boolean jj_3R_102() { 3285 Token xsp; 3286 xsp = jj_scanpos; 3287 if (jj_3R_105()) { 3288 jj_scanpos = xsp; 3289 if (jj_3R_106()) { 3290 jj_scanpos = xsp; 3291 if (jj_3R_107()) { 3292 jj_scanpos = xsp; 3293 if (jj_3R_108()) return true; 3294 } 3295 } 3296 } 3297 return false; 3298 } 3299 3300 private boolean jj_3R_71() { 3301 if (jj_3R_79()) return true; 3302 return false; 3303 } 3304 3305 private boolean jj_3R_25() { 3306 if (jj_3R_40()) return true; 3307 return false; 3308 } 3309 3310 private boolean jj_3R_70() { 3311 if (jj_3R_21()) return true; 3312 return false; 3313 } 3314 3315 private boolean jj_3R_19() { 3316 Token xsp; 3317 xsp = jj_scanpos; 3318 if (jj_3R_25()) { 3319 jj_scanpos = xsp; 3320 if (jj_3R_26()) { 3321 jj_scanpos = xsp; 3322 if (jj_3R_27()) { 3323 jj_scanpos = xsp; 3324 if (jj_3R_28()) { 3325 jj_scanpos = xsp; 3326 if (jj_3R_29()) { 3327 jj_scanpos = xsp; 3328 if (jj_3R_30()) { 3329 jj_scanpos = xsp; 3330 if (jj_3R_31()) return true; 3331 } 3332 } 3333 } 3334 } 3335 } 3336 } 3337 if (jj_3R_32()) return true; 3338 return false; 3339 } 3340 3341 private boolean jj_3_16() { 3342 if (jj_3R_21()) return true; 3343 if (jj_scan_token(LBRACKET)) return true; 3344 return false; 3345 } 3346 3347 private boolean jj_3R_111() { 3348 if (jj_scan_token(mod)) return true; 3349 if (jj_3R_102()) return true; 3350 return false; 3351 } 3352 3353 private boolean jj_3R_110() { 3354 if (jj_scan_token(div)) return true; 3355 if (jj_3R_102()) return true; 3356 return false; 3357 } 3358 3359 /** Generated Token Manager. */ 3360 public ParserTokenManager token_source; 3361 SimpleCharStream jj_input_stream; 3362 /** Current token. */ 3363 public Token token; 3364 /** Next token. */ 3365 public Token jj_nt; 3366 private int jj_ntk; 3367 private Token jj_scanpos, jj_lastpos; 3368 private int jj_la; 3369 private int jj_gen; 3370 final private int[] jj_la1 = new int[41]; 3371 static private int[] jj_la1_0; 3372 static private int[] jj_la1_1; 3373 static { 3374 jj_la1_init_0(); 3375 jj_la1_init_1(); 3376 } 3377 private static void jj_la1_init_0() { 3378 jj_la1_0 = new int[] {0xaaffa00,0x8000000,0x2affa00,0xaaffa00,0x2afc000,0x400,0x1800,0x2afc000,0x80000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2afc000,0x0,0xe0000,0xc0000,0x20000000,0x20000000,0x8000,0x20000000,0x2afc000,0x20000000,0x2afc000,0x20000000,0x2afc000,0xe0000,0x40000000,0x0,0x10000,0x0,}; 3379 } 3380 private static void jj_la1_init_1() { 3381 jj_la1_1 = new int[] {0x1e454000,0x0,0x1e454000,0x1e454000,0x1e454000,0x0,0x0,0x1e454000,0x1,0x1,0x4,0x2,0x100000,0x200000,0x80000,0x18,0x18,0x7e0,0x7e0,0x18000,0x18000,0x23000,0x23000,0x1e454000,0x2400000,0x1c000000,0x0,0x0,0x0,0x0,0x0,0x1e454000,0x0,0x1e454000,0x0,0x1e454000,0x1c000000,0x0,0x6400000,0x6400000,0x2400000,}; 3382 } 3383 final private JJCalls[] jj_2_rtns = new JJCalls[22]; 3384 private boolean jj_rescan = false; 3385 private int jj_gc = 0; 3386 3387 /** Constructor with InputStream. */ 3388 public Parser(java.io.InputStream stream) { 3389 this(stream, null); 3390 } 3391 /** Constructor with InputStream and supplied encoding */ 3392 public Parser(java.io.InputStream stream, String encoding) { 3393 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } 3394 token_source = new ParserTokenManager(jj_input_stream); 3395 token = new Token(); 3396 jj_ntk = -1; 3397 jj_gen = 0; 3398 for (int i = 0; i < 41; i++) jj_la1[i] = -1; 3399 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3400 } 3401 3402 /** Reinitialise. */ 3403 public void ReInit(java.io.InputStream stream) { 3404 ReInit(stream, null); 3405 } 3406 /** Reinitialise. */ 3407 public void ReInit(java.io.InputStream stream, String encoding) { 3408 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } 3409 token_source.ReInit(jj_input_stream); 3410 token = new Token(); 3411 jj_ntk = -1; 3412 jjtree.reset(); 3413 jj_gen = 0; 3414 for (int i = 0; i < 41; i++) jj_la1[i] = -1; 3415 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3416 } 3417 3418 /** Constructor. */ 3419 public Parser(java.io.Reader stream) { 3420 jj_input_stream = new SimpleCharStream(stream, 1, 1); 3421 token_source = new ParserTokenManager(jj_input_stream); 3422 token = new Token(); 3423 jj_ntk = -1; 3424 jj_gen = 0; 3425 for (int i = 0; i < 41; i++) jj_la1[i] = -1; 3426 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3427 } 3428 3429 /** Reinitialise. */ 3430 public void ReInit(java.io.Reader stream) { 3431 jj_input_stream.ReInit(stream, 1, 1); 3432 token_source.ReInit(jj_input_stream); 3433 token = new Token(); 3434 jj_ntk = -1; 3435 jjtree.reset(); 3436 jj_gen = 0; 3437 for (int i = 0; i < 41; i++) jj_la1[i] = -1; 3438 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3439 } 3440 3441 /** Constructor with generated Token Manager. */ 3442 public Parser(ParserTokenManager tm) { 3443 token_source = tm; 3444 token = new Token(); 3445 jj_ntk = -1; 3446 jj_gen = 0; 3447 for (int i = 0; i < 41; i++) jj_la1[i] = -1; 3448 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3449 } 3450 3451 /** Reinitialise. */ 3452 public void ReInit(ParserTokenManager tm) { 3453 token_source = tm; 3454 token = new Token(); 3455 jj_ntk = -1; 3456 jjtree.reset(); 3457 jj_gen = 0; 3458 for (int i = 0; i < 41; i++) jj_la1[i] = -1; 3459 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3460 } 3461 3462 private Token jj_consume_token(int kind) throws ParseException { 3463 Token oldToken; 3464 if ((oldToken = token).next != null) token = token.next; 3465 else token = token.next = token_source.getNextToken(); 3466 jj_ntk = -1; 3467 if (token.kind == kind) { 3468 jj_gen++; 3469 if (++jj_gc > 100) { 3470 jj_gc = 0; 3471 for (int i = 0; i < jj_2_rtns.length; i++) { 3472 JJCalls c = jj_2_rtns[i]; 3473 while (c != null) { 3474 if (c.gen < jj_gen) c.first = null; 3475 c = c.next; 3476 } 3477 } 3478 } 3479 return token; 3480 } 3481 token = oldToken; 3482 jj_kind = kind; 3483 throw generateParseException(); 3484 } 3485 3486 static private final class LookaheadSuccess extends java.lang.Error { } 3487 final private LookaheadSuccess jj_ls = new LookaheadSuccess(); 3488 private boolean jj_scan_token(int kind) { 3489 if (jj_scanpos == jj_lastpos) { 3490 jj_la--; 3491 if (jj_scanpos.next == null) { 3492 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); 3493 } else { 3494 jj_lastpos = jj_scanpos = jj_scanpos.next; 3495 } 3496 } else { 3497 jj_scanpos = jj_scanpos.next; 3498 } 3499 if (jj_rescan) { 3500 int i = 0; Token tok = token; 3501 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } 3502 if (tok != null) jj_add_error_token(kind, i); 3503 } 3504 if (jj_scanpos.kind != kind) return true; 3505 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; 3506 return false; 3507 } 3508 3509 3510 /** Get the next Token. */ 3511 final public Token getNextToken() { 3512 if (token.next != null) token = token.next; 3513 else token = token.next = token_source.getNextToken(); 3514 jj_ntk = -1; 3515 jj_gen++; 3516 return token; 3517 } 3518 3519 /** Get the specific Token. */ 3520 final public Token getToken(int index) { 3521 Token t = token; 3522 for (int i = 0; i < index; i++) { 3523 if (t.next != null) t = t.next; 3524 else t = t.next = token_source.getNextToken(); 3525 } 3526 return t; 3527 } 3528 3529 private int jj_ntk() { 3530 if ((jj_nt=token.next) == null) 3531 return (jj_ntk = (token.next=token_source.getNextToken()).kind); 3532 else 3533 return (jj_ntk = jj_nt.kind); 3534 } 3535 3536 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); 3537 private int[] jj_expentry; 3538 private int jj_kind = -1; 3539 private int[] jj_lasttokens = new int[100]; 3540 private int jj_endpos; 3541 3542 private void jj_add_error_token(int kind, int pos) { 3543 if (pos >= 100) return; 3544 if (pos == jj_endpos + 1) { 3545 jj_lasttokens[jj_endpos++] = kind; 3546 } else if (jj_endpos != 0) { 3547 jj_expentry = new int[jj_endpos]; 3548 for (int i = 0; i < jj_endpos; i++) { 3549 jj_expentry[i] = jj_lasttokens[i]; 3550 } 3551 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) { 3552 int[] oldentry = (int[])(it.next()); 3553 if (oldentry.length == jj_expentry.length) { 3554 for (int i = 0; i < jj_expentry.length; i++) { 3555 if (oldentry[i] != jj_expentry[i]) { 3556 continue jj_entries_loop; 3557 } 3558 } 3559 jj_expentries.add(jj_expentry); 3560 break jj_entries_loop; 3561 } 3562 } 3563 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; 3564 } 3565 } 3566 3567 /** Generate ParseException. */ 3568 public ParseException generateParseException() { 3569 jj_expentries.clear(); 3570 boolean[] la1tokens = new boolean[61]; 3571 if (jj_kind >= 0) { 3572 la1tokens[jj_kind] = true; 3573 jj_kind = -1; 3574 } 3575 for (int i = 0; i < 41; i++) { 3576 if (jj_la1[i] == jj_gen) { 3577 for (int j = 0; j < 32; j++) { 3578 if ((jj_la1_0[i] & (1<<j)) != 0) { 3579 la1tokens[j] = true; 3580 } 3581 if ((jj_la1_1[i] & (1<<j)) != 0) { 3582 la1tokens[32+j] = true; 3583 } 3584 } 3585 } 3586 } 3587 for (int i = 0; i < 61; i++) { 3588 if (la1tokens[i]) { 3589 jj_expentry = new int[1]; 3590 jj_expentry[0] = i; 3591 jj_expentries.add(jj_expentry); 3592 } 3593 } 3594 jj_endpos = 0; 3595 jj_rescan_token(); 3596 jj_add_error_token(0, 0); 3597 int[][] exptokseq = new int[jj_expentries.size()][]; 3598 for (int i = 0; i < jj_expentries.size(); i++) { 3599 exptokseq[i] = jj_expentries.get(i); 3600 } 3601 return new ParseException(token, exptokseq, tokenImage); 3602 } 3603 3604 /** Enable tracing. */ 3605 final public void enable_tracing() { 3606 } 3607 3608 /** Disable tracing. */ 3609 final public void disable_tracing() { 3610 } 3611 3612 private void jj_rescan_token() { 3613 jj_rescan = true; 3614 for (int i = 0; i < 22; i++) { 3615 try { 3616 JJCalls p = jj_2_rtns[i]; 3617 do { 3618 if (p.gen > jj_gen) { 3619 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; 3620 switch (i) { 3621 case 0: jj_3_1(); break; 3622 case 1: jj_3_2(); break; 3623 case 2: jj_3_3(); break; 3624 case 3: jj_3_4(); break; 3625 case 4: jj_3_5(); break; 3626 case 5: jj_3_6(); break; 3627 case 6: jj_3_7(); break; 3628 case 7: jj_3_8(); break; 3629 case 8: jj_3_9(); break; 3630 case 9: jj_3_10(); break; 3631 case 10: jj_3_11(); break; 3632 case 11: jj_3_12(); break; 3633 case 12: jj_3_13(); break; 3634 case 13: jj_3_14(); break; 3635 case 14: jj_3_15(); break; 3636 case 15: jj_3_16(); break; 3637 case 16: jj_3_17(); break; 3638 case 17: jj_3_18(); break; 3639 case 18: jj_3_19(); break; 3640 case 19: jj_3_20(); break; 3641 case 20: jj_3_21(); break; 3642 case 21: jj_3_22(); break; 3643 } 3644 } 3645 p = p.next; 3646 } while (p != null); 3647 } catch(LookaheadSuccess ls) { } 3648 } 3649 jj_rescan = false; 3650 } 3651 3652 private void jj_save(int index, int xla) { 3653 JJCalls p = jj_2_rtns[index]; 3654 while (p.gen > jj_gen) { 3655 if (p.next == null) { p = p.next = new JJCalls(); break; } 3656 p = p.next; 3657 } 3658 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; 3659 } 3660 3661 static final class JJCalls { 3662 int gen; 3663 Token first; 3664 int arg; 3665 JJCalls next; 3666 } 3667 3668 }