1 16 17 package org.apache.commons.jexl.parser; 18 19 import java.io.Reader ; 20 21 public class Parserimplements ParserTreeConstants, ParserConstants { 22 protected JJTParserState jjtree = new JJTParserState(); 23 24 public SimpleNode parse(Reader reader) throws Exception { 25 ReInit(reader); 26 27 31 32 SimpleNode tree = JexlScript(); 33 return tree; 34 } 35 36 39 public final SimpleNode JexlScript() throws ParseException { 40 41 ASTJexlScript jjtn000 = new ASTJexlScript(this, JJTJEXLSCRIPT); 42 boolean jjtc000 = true; 43 jjtree.openNodeScope(jjtn000); 44 String name; 45 try { 46 label_1: while (true) { 47 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 48 case INTEGER_LITERAL: 49 case FLOAT_LITERAL: 50 case 9: 51 case 11: 52 case 12: 53 case 14: 54 case 36: 55 case 42: 56 case 43: 57 case 44: 58 case 45: 59 case 46: 60 case 47: 61 case 48: 62 case 49: 63 case 51: 64 case 52: 65 case IDENTIFIER: 66 case STRING_LITERAL: 67 ; 68 break; 69 default: 70 jj_la1[0] = jj_gen; 71 break label_1; 72 } 73 Statement(); 74 } 75 jj_consume_token(0); 76 jjtree.closeNodeScope(jjtn000, true); 77 jjtc000 = false; 78 { 79 if (true) 80 return jjtn000; 81 } 82 } catch (Throwable jjte000) { 83 if (jjtc000) { 84 jjtree.clearNodeScope(jjtn000); 85 jjtc000 = false; 86 } else { 87 jjtree.popNode(); 88 } 89 if (jjte000 instanceof RuntimeException ) { 90 { 91 if (true) 92 throw (RuntimeException ) jjte000; 93 } 94 } 95 if (jjte000 instanceof ParseException) { 96 { 97 if (true) 98 throw (ParseException) jjte000; 99 } 100 } 101 { 102 if (true) 103 throw (Error ) jjte000; 104 } 105 } finally { 106 if (jjtc000) { 107 jjtree.closeNodeScope(jjtn000, true); 108 } 109 } 110 throw new Error ("Missing return statement in function"); 111 } 112 113 final public void Block() throws ParseException { 114 115 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK); 116 boolean jjtc000 = true; 117 jjtree.openNodeScope(jjtn000); 118 try { 119 jj_consume_token(9); 120 label_2: while (true) { 121 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 122 case INTEGER_LITERAL: 123 case FLOAT_LITERAL: 124 case 9: 125 case 11: 126 case 12: 127 case 14: 128 case 36: 129 case 42: 130 case 43: 131 case 44: 132 case 45: 133 case 46: 134 case 47: 135 case 48: 136 case 49: 137 case 51: 138 case 52: 139 case IDENTIFIER: 140 case STRING_LITERAL: 141 ; 142 break; 143 default: 144 jj_la1[1] = jj_gen; 145 break label_2; 146 } 147 Statement(); 148 } 149 jj_consume_token(10); 150 } catch (Throwable jjte000) { 151 if (jjtc000) { 152 jjtree.clearNodeScope(jjtn000); 153 jjtc000 = false; 154 } else { 155 jjtree.popNode(); 156 } 157 if (jjte000 instanceof RuntimeException ) { 158 { 159 if (true) 160 throw (RuntimeException ) jjte000; 161 } 162 } 163 if (jjte000 instanceof ParseException) { 164 { 165 if (true) 166 throw (ParseException) jjte000; 167 } 168 } 169 { 170 if (true) 171 throw (Error ) jjte000; 172 } 173 } finally { 174 if (jjtc000) { 175 jjtree.closeNodeScope(jjtn000, true); 176 } 177 } 178 } 179 180 final public void EmptyFunction() throws ParseException { 181 182 ASTEmptyFunction jjtn000 = new ASTEmptyFunction(this, JJTEMPTYFUNCTION); 183 boolean jjtc000 = true; 184 jjtree.openNodeScope(jjtn000); 185 try { 186 jj_consume_token(11); 187 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 188 case IDENTIFIER: 189 Reference(); 190 break; 191 case 12: 192 jj_consume_token(12); 193 Reference(); 194 jj_consume_token(13); 195 break; 196 default: 197 jj_la1[2] = jj_gen; 198 jj_consume_token(-1); 199 throw new ParseException(); 200 } 201 } catch (Throwable jjte000) { 202 if (jjtc000) { 203 jjtree.clearNodeScope(jjtn000); 204 jjtc000 = false; 205 } else { 206 jjtree.popNode(); 207 } 208 if (jjte000 instanceof RuntimeException ) { 209 { 210 if (true) 211 throw (RuntimeException ) jjte000; 212 } 213 } 214 if (jjte000 instanceof ParseException) { 215 { 216 if (true) 217 throw (ParseException) jjte000; 218 } 219 } 220 { 221 if (true) 222 throw (Error ) jjte000; 223 } 224 } finally { 225 if (jjtc000) { 226 jjtree.closeNodeScope(jjtn000, true); 227 } 228 } 229 } 230 231 final public void SizeFunction() throws ParseException { 232 233 ASTSizeFunction jjtn000 = new ASTSizeFunction(this, JJTSIZEFUNCTION); 234 boolean jjtc000 = true; 235 jjtree.openNodeScope(jjtn000); 236 try { 237 jj_consume_token(14); 238 jj_consume_token(12); 239 Reference(); 240 jj_consume_token(13); 241 } catch (Throwable jjte000) { 242 if (jjtc000) { 243 jjtree.clearNodeScope(jjtn000); 244 jjtc000 = false; 245 } else { 246 jjtree.popNode(); 247 } 248 if (jjte000 instanceof RuntimeException ) { 249 { 250 if (true) 251 throw (RuntimeException ) jjte000; 252 } 253 } 254 if (jjte000 instanceof ParseException) { 255 { 256 if (true) 257 throw (ParseException) jjte000; 258 } 259 } 260 { 261 if (true) 262 throw (Error ) jjte000; 263 } 264 } finally { 265 if (jjtc000) { 266 jjtree.closeNodeScope(jjtn000, true); 267 } 268 } 269 } 270 271 final public void Identifier() throws ParseException { 272 273 ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER); 274 boolean jjtc000 = true; 275 jjtree.openNodeScope(jjtn000); 276 Token t; 277 try { 278 t = jj_consume_token(IDENTIFIER); 279 jjtree.closeNodeScope(jjtn000, true); 280 jjtc000 = false; 281 jjtn000.val = t.image; 282 } finally { 283 if (jjtc000) { 284 jjtree.closeNodeScope(jjtn000, true); 285 } 286 } 287 } 288 289 292 final public void Expression() throws ParseException { 293 294 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION); 295 boolean jjtc000 = true; 296 jjtree.openNodeScope(jjtn000); 297 try { 298 if (jj_2_1(2147483647)) { 299 Assignment(); 300 } else { 301 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 302 case INTEGER_LITERAL: 303 case FLOAT_LITERAL: 304 case 11: 305 case 12: 306 case 14: 307 case 36: 308 case 42: 309 case 43: 310 case 44: 311 case 45: 312 case 46: 313 case 47: 314 case IDENTIFIER: 315 case STRING_LITERAL: 316 ConditionalOrExpression(); 317 break; 318 default: 319 jj_la1[3] = jj_gen; 320 jj_consume_token(-1); 321 throw new ParseException(); 322 } 323 } 324 } catch (Throwable jjte000) { 325 if (jjtc000) { 326 jjtree.clearNodeScope(jjtn000); 327 jjtc000 = false; 328 } else { 329 jjtree.popNode(); 330 } 331 if (jjte000 instanceof RuntimeException ) { 332 { 333 if (true) 334 throw (RuntimeException ) jjte000; 335 } 336 } 337 if (jjte000 instanceof ParseException) { 338 { 339 if (true) 340 throw (ParseException) jjte000; 341 } 342 } 343 { 344 if (true) 345 throw (Error ) jjte000; 346 } 347 } finally { 348 if (jjtc000) { 349 jjtree.closeNodeScope(jjtn000, true); 350 } 351 } 352 } 353 354 final public void Assignment() throws ParseException { 355 356 ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT); 357 boolean jjtc000 = true; 358 jjtree.openNodeScope(jjtn000); 359 try { 360 PrimaryExpression(); 361 jj_consume_token(15); 362 Expression(); 363 } catch (Throwable jjte000) { 364 if (jjtc000) { 365 jjtree.clearNodeScope(jjtn000); 366 jjtc000 = false; 367 } else { 368 jjtree.popNode(); 369 } 370 if (jjte000 instanceof RuntimeException ) { 371 { 372 if (true) 373 throw (RuntimeException ) jjte000; 374 } 375 } 376 if (jjte000 instanceof ParseException) { 377 { 378 if (true) 379 throw (ParseException) jjte000; 380 } 381 } 382 { 383 if (true) 384 throw (Error ) jjte000; 385 } 386 } finally { 387 if (jjtc000) { 388 jjtree.closeNodeScope(jjtn000, 2); 389 } 390 } 391 } 392 393 final public void ConditionalOrExpression() throws ParseException { 394 ConditionalAndExpression(); 395 label_3: while (true) { 396 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 397 case 16: 398 case 17: 399 ; 400 break; 401 default: 402 jj_la1[4] = jj_gen; 403 break label_3; 404 } 405 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 406 case 16: 407 jj_consume_token(16); 408 ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE); 409 boolean jjtc001 = true; 410 jjtree.openNodeScope(jjtn001); 411 try { 412 ConditionalAndExpression(); 413 } catch (Throwable jjte001) { 414 if (jjtc001) { 415 jjtree.clearNodeScope(jjtn001); 416 jjtc001 = false; 417 } else { 418 jjtree.popNode(); 419 } 420 if (jjte001 instanceof RuntimeException ) { 421 { 422 if (true) 423 throw (RuntimeException ) jjte001; 424 } 425 } 426 if (jjte001 instanceof ParseException) { 427 { 428 if (true) 429 throw (ParseException) jjte001; 430 } 431 } 432 { 433 if (true) 434 throw (Error ) jjte001; 435 } 436 } finally { 437 if (jjtc001) { 438 jjtree.closeNodeScope(jjtn001, 2); 439 } 440 } 441 break; 442 case 17: 443 jj_consume_token(17); 444 ASTOrNode jjtn002 = new ASTOrNode(this, JJTORNODE); 445 boolean jjtc002 = true; 446 jjtree.openNodeScope(jjtn002); 447 try { 448 ConditionalAndExpression(); 449 } catch (Throwable jjte002) { 450 if (jjtc002) { 451 jjtree.clearNodeScope(jjtn002); 452 jjtc002 = false; 453 } else { 454 jjtree.popNode(); 455 } 456 if (jjte002 instanceof RuntimeException ) { 457 { 458 if (true) 459 throw (RuntimeException ) jjte002; 460 } 461 } 462 if (jjte002 instanceof ParseException) { 463 { 464 if (true) 465 throw (ParseException) jjte002; 466 } 467 } 468 { 469 if (true) 470 throw (Error ) jjte002; 471 } 472 } finally { 473 if (jjtc002) { 474 jjtree.closeNodeScope(jjtn002, 2); 475 } 476 } 477 break; 478 default: 479 jj_la1[5] = jj_gen; 480 jj_consume_token(-1); 481 throw new ParseException(); 482 } 483 } 484 } 485 486 final public void ConditionalAndExpression() throws ParseException { 487 InclusiveOrExpression(); 488 label_4: while (true) { 489 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 490 case 18: 491 case 19: 492 ; 493 break; 494 default: 495 jj_la1[6] = jj_gen; 496 break label_4; 497 } 498 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 499 case 18: 500 jj_consume_token(18); 501 ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE); 502 boolean jjtc001 = true; 503 jjtree.openNodeScope(jjtn001); 504 try { 505 InclusiveOrExpression(); 506 } catch (Throwable jjte001) { 507 if (jjtc001) { 508 jjtree.clearNodeScope(jjtn001); 509 jjtc001 = false; 510 } else { 511 jjtree.popNode(); 512 } 513 if (jjte001 instanceof RuntimeException ) { 514 { 515 if (true) 516 throw (RuntimeException ) jjte001; 517 } 518 } 519 if (jjte001 instanceof ParseException) { 520 { 521 if (true) 522 throw (ParseException) jjte001; 523 } 524 } 525 { 526 if (true) 527 throw (Error ) jjte001; 528 } 529 } finally { 530 if (jjtc001) { 531 jjtree.closeNodeScope(jjtn001, 2); 532 } 533 } 534 break; 535 case 19: 536 jj_consume_token(19); 537 ASTAndNode jjtn002 = new ASTAndNode(this, JJTANDNODE); 538 boolean jjtc002 = true; 539 jjtree.openNodeScope(jjtn002); 540 try { 541 InclusiveOrExpression(); 542 } catch (Throwable jjte002) { 543 if (jjtc002) { 544 jjtree.clearNodeScope(jjtn002); 545 jjtc002 = false; 546 } else { 547 jjtree.popNode(); 548 } 549 if (jjte002 instanceof RuntimeException ) { 550 { 551 if (true) 552 throw (RuntimeException ) jjte002; 553 } 554 } 555 if (jjte002 instanceof ParseException) { 556 { 557 if (true) 558 throw (ParseException) jjte002; 559 } 560 } 561 { 562 if (true) 563 throw (Error ) jjte002; 564 } 565 } finally { 566 if (jjtc002) { 567 jjtree.closeNodeScope(jjtn002, 2); 568 } 569 } 570 break; 571 default: 572 jj_la1[7] = jj_gen; 573 jj_consume_token(-1); 574 throw new ParseException(); 575 } 576 } 577 } 578 579 final public void InclusiveOrExpression() throws ParseException { 580 ExclusiveOrExpression(); 581 label_5: while (true) { 582 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 583 case 20: 584 ; 585 break; 586 default: 587 jj_la1[8] = jj_gen; 588 break label_5; 589 } 590 jj_consume_token(20); 591 ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(this, JJTBITWISEORNODE); 592 boolean jjtc001 = true; 593 jjtree.openNodeScope(jjtn001); 594 try { 595 ExclusiveOrExpression(); 596 } catch (Throwable jjte001) { 597 if (jjtc001) { 598 jjtree.clearNodeScope(jjtn001); 599 jjtc001 = false; 600 } else { 601 jjtree.popNode(); 602 } 603 if (jjte001 instanceof RuntimeException ) { 604 { 605 if (true) 606 throw (RuntimeException ) jjte001; 607 } 608 } 609 if (jjte001 instanceof ParseException) { 610 { 611 if (true) 612 throw (ParseException) jjte001; 613 } 614 } 615 { 616 if (true) 617 throw (Error ) jjte001; 618 } 619 } finally { 620 if (jjtc001) { 621 jjtree.closeNodeScope(jjtn001, 2); 622 } 623 } 624 } 625 } 626 627 final public void ExclusiveOrExpression() throws ParseException { 628 AndExpression(); 629 label_6: while (true) { 630 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 631 case 21: 632 ; 633 break; 634 default: 635 jj_la1[9] = jj_gen; 636 break label_6; 637 } 638 jj_consume_token(21); 639 ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(this, JJTBITWISEXORNODE); 640 boolean jjtc001 = true; 641 jjtree.openNodeScope(jjtn001); 642 try { 643 AndExpression(); 644 } catch (Throwable jjte001) { 645 if (jjtc001) { 646 jjtree.clearNodeScope(jjtn001); 647 jjtc001 = false; 648 } else { 649 jjtree.popNode(); 650 } 651 if (jjte001 instanceof RuntimeException ) { 652 { 653 if (true) 654 throw (RuntimeException ) jjte001; 655 } 656 } 657 if (jjte001 instanceof ParseException) { 658 { 659 if (true) 660 throw (ParseException) jjte001; 661 } 662 } 663 { 664 if (true) 665 throw (Error ) jjte001; 666 } 667 } finally { 668 if (jjtc001) { 669 jjtree.closeNodeScope(jjtn001, 2); 670 } 671 } 672 } 673 } 674 675 final public void AndExpression() throws ParseException { 676 EqualityExpression(); 677 label_7: while (true) { 678 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 679 case 22: 680 ; 681 break; 682 default: 683 jj_la1[10] = jj_gen; 684 break label_7; 685 } 686 jj_consume_token(22); 687 ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(this, JJTBITWISEANDNODE); 688 boolean jjtc001 = true; 689 jjtree.openNodeScope(jjtn001); 690 try { 691 EqualityExpression(); 692 } catch (Throwable jjte001) { 693 if (jjtc001) { 694 jjtree.clearNodeScope(jjtn001); 695 jjtc001 = false; 696 } else { 697 jjtree.popNode(); 698 } 699 if (jjte001 instanceof RuntimeException ) { 700 { 701 if (true) 702 throw (RuntimeException ) jjte001; 703 } 704 } 705 if (jjte001 instanceof ParseException) { 706 { 707 if (true) 708 throw (ParseException) jjte001; 709 } 710 } 711 { 712 if (true) 713 throw (Error ) jjte001; 714 } 715 } finally { 716 if (jjtc001) { 717 jjtree.closeNodeScope(jjtn001, 2); 718 } 719 } 720 } 721 } 722 723 final public void EqualityExpression() throws ParseException { 724 RelationalExpression(); 725 label_8: while (true) { 726 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 727 case 23: 728 case 24: 729 case 25: 730 case 26: 731 ; 732 break; 733 default: 734 jj_la1[11] = jj_gen; 735 break label_8; 736 } 737 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 738 case 23: 739 jj_consume_token(23); 740 ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE); 741 boolean jjtc001 = true; 742 jjtree.openNodeScope(jjtn001); 743 try { 744 RelationalExpression(); 745 } catch (Throwable jjte001) { 746 if (jjtc001) { 747 jjtree.clearNodeScope(jjtn001); 748 jjtc001 = false; 749 } else { 750 jjtree.popNode(); 751 } 752 if (jjte001 instanceof RuntimeException ) { 753 { 754 if (true) 755 throw (RuntimeException ) jjte001; 756 } 757 } 758 if (jjte001 instanceof ParseException) { 759 { 760 if (true) 761 throw (ParseException) jjte001; 762 } 763 } 764 { 765 if (true) 766 throw (Error ) jjte001; 767 } 768 } finally { 769 if (jjtc001) { 770 jjtree.closeNodeScope(jjtn001, 2); 771 } 772 } 773 break; 774 case 24: 775 jj_consume_token(24); 776 ASTEQNode jjtn002 = new ASTEQNode(this, JJTEQNODE); 777 boolean jjtc002 = true; 778 jjtree.openNodeScope(jjtn002); 779 try { 780 RelationalExpression(); 781 } catch (Throwable jjte002) { 782 if (jjtc002) { 783 jjtree.clearNodeScope(jjtn002); 784 jjtc002 = false; 785 } else { 786 jjtree.popNode(); 787 } 788 if (jjte002 instanceof RuntimeException ) { 789 { 790 if (true) 791 throw (RuntimeException ) jjte002; 792 } 793 } 794 if (jjte002 instanceof ParseException) { 795 { 796 if (true) 797 throw (ParseException) jjte002; 798 } 799 } 800 { 801 if (true) 802 throw (Error ) jjte002; 803 } 804 } finally { 805 if (jjtc002) { 806 jjtree.closeNodeScope(jjtn002, 2); 807 } 808 } 809 break; 810 case 25: 811 jj_consume_token(25); 812 ASTNENode jjtn003 = new ASTNENode(this, JJTNENODE); 813 boolean jjtc003 = true; 814 jjtree.openNodeScope(jjtn003); 815 try { 816 RelationalExpression(); 817 } catch (Throwable jjte003) { 818 if (jjtc003) { 819 jjtree.clearNodeScope(jjtn003); 820 jjtc003 = false; 821 } else { 822 jjtree.popNode(); 823 } 824 if (jjte003 instanceof RuntimeException ) { 825 { 826 if (true) 827 throw (RuntimeException ) jjte003; 828 } 829 } 830 if (jjte003 instanceof ParseException) { 831 { 832 if (true) 833 throw (ParseException) jjte003; 834 } 835 } 836 { 837 if (true) 838 throw (Error ) jjte003; 839 } 840 } finally { 841 if (jjtc003) { 842 jjtree.closeNodeScope(jjtn003, 2); 843 } 844 } 845 break; 846 case 26: 847 jj_consume_token(26); 848 ASTNENode jjtn004 = new ASTNENode(this, JJTNENODE); 849 boolean jjtc004 = true; 850 jjtree.openNodeScope(jjtn004); 851 try { 852 RelationalExpression(); 853 } catch (Throwable jjte004) { 854 if (jjtc004) { 855 jjtree.clearNodeScope(jjtn004); 856 jjtc004 = false; 857 } else { 858 jjtree.popNode(); 859 } 860 if (jjte004 instanceof RuntimeException ) { 861 { 862 if (true) 863 throw (RuntimeException ) jjte004; 864 } 865 } 866 if (jjte004 instanceof ParseException) { 867 { 868 if (true) 869 throw (ParseException) jjte004; 870 } 871 } 872 { 873 if (true) 874 throw (Error ) jjte004; 875 } 876 } finally { 877 if (jjtc004) { 878 jjtree.closeNodeScope(jjtn004, 2); 879 } 880 } 881 break; 882 default: 883 jj_la1[12] = jj_gen; 884 jj_consume_token(-1); 885 throw new ParseException(); 886 } 887 } 888 } 889 890 final public void RelationalExpression() throws ParseException { 891 AdditiveExpression(); 892 label_9: while (true) { 893 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 894 case 27: 895 case 28: 896 case 29: 897 case 30: 898 case 31: 899 case 32: 900 case 33: 901 case 34: 902 ; 903 break; 904 default: 905 jj_la1[13] = jj_gen; 906 break label_9; 907 } 908 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 909 case 27: 910 jj_consume_token(27); 911 ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE); 912 boolean jjtc001 = true; 913 jjtree.openNodeScope(jjtn001); 914 try { 915 AdditiveExpression(); 916 } catch (Throwable jjte001) { 917 if (jjtc001) { 918 jjtree.clearNodeScope(jjtn001); 919 jjtc001 = false; 920 } else { 921 jjtree.popNode(); 922 } 923 if (jjte001 instanceof RuntimeException ) { 924 { 925 if (true) 926 throw (RuntimeException ) jjte001; 927 } 928 } 929 if (jjte001 instanceof ParseException) { 930 { 931 if (true) 932 throw (ParseException) jjte001; 933 } 934 } 935 { 936 if (true) 937 throw (Error ) jjte001; 938 } 939 } finally { 940 if (jjtc001) { 941 jjtree.closeNodeScope(jjtn001, 2); 942 } 943 } 944 break; 945 case 28: 946 jj_consume_token(28); 947 ASTLTNode jjtn002 = new ASTLTNode(this, JJTLTNODE); 948 boolean jjtc002 = true; 949 jjtree.openNodeScope(jjtn002); 950 try { 951 AdditiveExpression(); 952 } catch (Throwable jjte002) { 953 if (jjtc002) { 954 jjtree.clearNodeScope(jjtn002); 955 jjtc002 = false; 956 } else { 957 jjtree.popNode(); 958 } 959 if (jjte002 instanceof RuntimeException ) { 960 { 961 if (true) 962 throw (RuntimeException ) jjte002; 963 } 964 } 965 if (jjte002 instanceof ParseException) { 966 { 967 if (true) 968 throw (ParseException) jjte002; 969 } 970 } 971 { 972 if (true) 973 throw (Error ) jjte002; 974 } 975 } finally { 976 if (jjtc002) { 977 jjtree.closeNodeScope(jjtn002, 2); 978 } 979 } 980 break; 981 case 29: 982 jj_consume_token(29); 983 ASTGTNode jjtn003 = new ASTGTNode(this, JJTGTNODE); 984 boolean jjtc003 = true; 985 jjtree.openNodeScope(jjtn003); 986 try { 987 AdditiveExpression(); 988 } catch (Throwable jjte003) { 989 if (jjtc003) { 990 jjtree.clearNodeScope(jjtn003); 991 jjtc003 = false; 992 } else { 993 jjtree.popNode(); 994 } 995 if (jjte003 instanceof RuntimeException ) { 996 { 997 if (true) 998 throw (RuntimeException ) jjte003; 999 } 1000 } 1001 if (jjte003 instanceof ParseException) { 1002 { 1003 if (true) 1004 throw (ParseException) jjte003; 1005 } 1006 } 1007 { 1008 if (true) 1009 throw (Error ) jjte003; 1010 } 1011 } finally { 1012 if (jjtc003) { 1013 jjtree.closeNodeScope(jjtn003, 2); 1014 } 1015 } 1016 break; 1017 case 30: 1018 jj_consume_token(30); 1019 ASTGTNode jjtn004 = new ASTGTNode(this, JJTGTNODE); 1020 boolean jjtc004 = true; 1021 jjtree.openNodeScope(jjtn004); 1022 try { 1023 AdditiveExpression(); 1024 } catch (Throwable jjte004) { 1025 if (jjtc004) { 1026 jjtree.clearNodeScope(jjtn004); 1027 jjtc004 = false; 1028 } else { 1029 jjtree.popNode(); 1030 } 1031 if (jjte004 instanceof RuntimeException ) { 1032 { 1033 if (true) 1034 throw (RuntimeException ) jjte004; 1035 } 1036 } 1037 if (jjte004 instanceof ParseException) { 1038 { 1039 if (true) 1040 throw (ParseException) jjte004; 1041 } 1042 } 1043 { 1044 if (true) 1045 throw (Error ) jjte004; 1046 } 1047 } finally { 1048 if (jjtc004) { 1049 jjtree.closeNodeScope(jjtn004, 2); 1050 } 1051 } 1052 break; 1053 case 31: 1054 jj_consume_token(31); 1055 ASTLENode jjtn005 = new ASTLENode(this, JJTLENODE); 1056 boolean jjtc005 = true; 1057 jjtree.openNodeScope(jjtn005); 1058 try { 1059 AdditiveExpression(); 1060 } catch (Throwable jjte005) { 1061 if (jjtc005) { 1062 jjtree.clearNodeScope(jjtn005); 1063 jjtc005 = false; 1064 } else { 1065 jjtree.popNode(); 1066 } 1067 if (jjte005 instanceof RuntimeException ) { 1068 { 1069 if (true) 1070 throw (RuntimeException ) jjte005; 1071 } 1072 } 1073 if (jjte005 instanceof ParseException) { 1074 { 1075 if (true) 1076 throw (ParseException) jjte005; 1077 } 1078 } 1079 { 1080 if (true) 1081 throw (Error ) jjte005; 1082 } 1083 } finally { 1084 if (jjtc005) { 1085 jjtree.closeNodeScope(jjtn005, 2); 1086 } 1087 } 1088 break; 1089 case 32: 1090 jj_consume_token(32); 1091 ASTLENode jjtn006 = new ASTLENode(this, JJTLENODE); 1092 boolean jjtc006 = true; 1093 jjtree.openNodeScope(jjtn006); 1094 try { 1095 AdditiveExpression(); 1096 } catch (Throwable jjte006) { 1097 if (jjtc006) { 1098 jjtree.clearNodeScope(jjtn006); 1099 jjtc006 = false; 1100 } else { 1101 jjtree.popNode(); 1102 } 1103 if (jjte006 instanceof RuntimeException ) { 1104 { 1105 if (true) 1106 throw (RuntimeException ) jjte006; 1107 } 1108 } 1109 if (jjte006 instanceof ParseException) { 1110 { 1111 if (true) 1112 throw (ParseException) jjte006; 1113 } 1114 } 1115 { 1116 if (true) 1117 throw (Error ) jjte006; 1118 } 1119 } finally { 1120 if (jjtc006) { 1121 jjtree.closeNodeScope(jjtn006, 2); 1122 } 1123 } 1124 break; 1125 case 33: 1126 jj_consume_token(33); 1127 ASTGENode jjtn007 = new ASTGENode(this, JJTGENODE); 1128 boolean jjtc007 = true; 1129 jjtree.openNodeScope(jjtn007); 1130 try { 1131 AdditiveExpression(); 1132 } catch (Throwable jjte007) { 1133 if (jjtc007) { 1134 jjtree.clearNodeScope(jjtn007); 1135 jjtc007 = false; 1136 } else { 1137 jjtree.popNode(); 1138 } 1139 if (jjte007 instanceof RuntimeException ) { 1140 { 1141 if (true) 1142 throw (RuntimeException ) jjte007; 1143 } 1144 } 1145 if (jjte007 instanceof ParseException) { 1146 { 1147 if (true) 1148 throw (ParseException) jjte007; 1149 } 1150 } 1151 { 1152 if (true) 1153 throw (Error ) jjte007; 1154 } 1155 } finally { 1156 if (jjtc007) { 1157 jjtree.closeNodeScope(jjtn007, 2); 1158 } 1159 } 1160 break; 1161 case 34: 1162 jj_consume_token(34); 1163 ASTGENode jjtn008 = new ASTGENode(this, JJTGENODE); 1164 boolean jjtc008 = true; 1165 jjtree.openNodeScope(jjtn008); 1166 try { 1167 AdditiveExpression(); 1168 } catch (Throwable jjte008) { 1169 if (jjtc008) { 1170 jjtree.clearNodeScope(jjtn008); 1171 jjtc008 = false; 1172 } else { 1173 jjtree.popNode(); 1174 } 1175 if (jjte008 instanceof RuntimeException ) { 1176 { 1177 if (true) 1178 throw (RuntimeException ) jjte008; 1179 } 1180 } 1181 if (jjte008 instanceof ParseException) { 1182 { 1183 if (true) 1184 throw (ParseException) jjte008; 1185 } 1186 } 1187 { 1188 if (true) 1189 throw (Error ) jjte008; 1190 } 1191 } finally { 1192 if (jjtc008) { 1193 jjtree.closeNodeScope(jjtn008, 2); 1194 } 1195 } 1196 break; 1197 default: 1198 jj_la1[14] = jj_gen; 1199 jj_consume_token(-1); 1200 throw new ParseException(); 1201 } 1202 } 1203 } 1204 1205 final public void AdditiveExpression() throws ParseException { 1206 MultiplicativeExpression(); 1207 label_10: while (true) { 1208 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1209 case 35: 1210 case 36: 1211 ; 1212 break; 1213 default: 1214 jj_la1[15] = jj_gen; 1215 break label_10; 1216 } 1217 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1218 case 35: 1219 jj_consume_token(35); 1220 ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE); 1221 boolean jjtc001 = true; 1222 jjtree.openNodeScope(jjtn001); 1223 try { 1224 MultiplicativeExpression(); 1225 } catch (Throwable jjte001) { 1226 if (jjtc001) { 1227 jjtree.clearNodeScope(jjtn001); 1228 jjtc001 = false; 1229 } else { 1230 jjtree.popNode(); 1231 } 1232 if (jjte001 instanceof RuntimeException ) { 1233 { 1234 if (true) 1235 throw (RuntimeException ) jjte001; 1236 } 1237 } 1238 if (jjte001 instanceof ParseException) { 1239 { 1240 if (true) 1241 throw (ParseException) jjte001; 1242 } 1243 } 1244 { 1245 if (true) 1246 throw (Error ) jjte001; 1247 } 1248 } finally { 1249 if (jjtc001) { 1250 jjtree.closeNodeScope(jjtn001, 2); 1251 } 1252 } 1253 break; 1254 case 36: 1255 jj_consume_token(36); 1256 ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE); 1257 boolean jjtc002 = true; 1258 jjtree.openNodeScope(jjtn002); 1259 try { 1260 MultiplicativeExpression(); 1261 } catch (Throwable jjte002) { 1262 if (jjtc002) { 1263 jjtree.clearNodeScope(jjtn002); 1264 jjtc002 = false; 1265 } else { 1266 jjtree.popNode(); 1267 } 1268 if (jjte002 instanceof RuntimeException ) { 1269 { 1270 if (true) 1271 throw (RuntimeException ) jjte002; 1272 } 1273 } 1274 if (jjte002 instanceof ParseException) { 1275 { 1276 if (true) 1277 throw (ParseException) jjte002; 1278 } 1279 } 1280 { 1281 if (true) 1282 throw (Error ) jjte002; 1283 } 1284 } finally { 1285 if (jjtc002) { 1286 jjtree.closeNodeScope(jjtn002, 2); 1287 } 1288 } 1289 break; 1290 default: 1291 jj_la1[16] = jj_gen; 1292 jj_consume_token(-1); 1293 throw new ParseException(); 1294 } 1295 } 1296 } 1297 1298 final public void MultiplicativeExpression() throws ParseException { 1299 UnaryExpression(); 1300 label_11: while (true) { 1301 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1302 case 37: 1303 case 38: 1304 case 39: 1305 case 40: 1306 case 41: 1307 ; 1308 break; 1309 default: 1310 jj_la1[17] = jj_gen; 1311 break label_11; 1312 } 1313 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1314 case 37: 1315 jj_consume_token(37); 1316 ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE); 1317 boolean jjtc001 = true; 1318 jjtree.openNodeScope(jjtn001); 1319 try { 1320 UnaryExpression(); 1321 } catch (Throwable jjte001) { 1322 if (jjtc001) { 1323 jjtree.clearNodeScope(jjtn001); 1324 jjtc001 = false; 1325 } else { 1326 jjtree.popNode(); 1327 } 1328 if (jjte001 instanceof RuntimeException ) { 1329 { 1330 if (true) 1331 throw (RuntimeException ) jjte001; 1332 } 1333 } 1334 if (jjte001 instanceof ParseException) { 1335 { 1336 if (true) 1337 throw (ParseException) jjte001; 1338 } 1339 } 1340 { 1341 if (true) 1342 throw (Error ) jjte001; 1343 } 1344 } finally { 1345 if (jjtc001) { 1346 jjtree.closeNodeScope(jjtn001, 2); 1347 } 1348 } 1349 break; 1350 case 38: 1351 jj_consume_token(38); 1352 ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE); 1353 boolean jjtc002 = true; 1354 jjtree.openNodeScope(jjtn002); 1355 try { 1356 UnaryExpression(); 1357 } catch (Throwable jjte002) { 1358 if (jjtc002) { 1359 jjtree.clearNodeScope(jjtn002); 1360 jjtc002 = false; 1361 } else { 1362 jjtree.popNode(); 1363 } 1364 if (jjte002 instanceof RuntimeException ) { 1365 { 1366 if (true) 1367 throw (RuntimeException ) jjte002; 1368 } 1369 } 1370 if (jjte002 instanceof ParseException) { 1371 { 1372 if (true) 1373 throw (ParseException) jjte002; 1374 } 1375 } 1376 { 1377 if (true) 1378 throw (Error ) jjte002; 1379 } 1380 } finally { 1381 if (jjtc002) { 1382 jjtree.closeNodeScope(jjtn002, 2); 1383 } 1384 } 1385 break; 1386 case 39: 1387 jj_consume_token(39); 1388 ASTDivNode jjtn003 = new ASTDivNode(this, JJTDIVNODE); 1389 boolean jjtc003 = true; 1390 jjtree.openNodeScope(jjtn003); 1391 try { 1392 UnaryExpression(); 1393 } catch (Throwable jjte003) { 1394 if (jjtc003) { 1395 jjtree.clearNodeScope(jjtn003); 1396 jjtc003 = false; 1397 } else { 1398 jjtree.popNode(); 1399 } 1400 if (jjte003 instanceof RuntimeException ) { 1401 { 1402 if (true) 1403 throw (RuntimeException ) jjte003; 1404 } 1405 } 1406 if (jjte003 instanceof ParseException) { 1407 { 1408 if (true) 1409 throw (ParseException) jjte003; 1410 } 1411 } 1412 { 1413 if (true) 1414 throw (Error ) jjte003; 1415 } 1416 } finally { 1417 if (jjtc003) { 1418 jjtree.closeNodeScope(jjtn003, 2); 1419 } 1420 } 1421 break; 1422 case 40: 1423 jj_consume_token(40); 1424 ASTModNode jjtn004 = new ASTModNode(this, JJTMODNODE); 1425 boolean jjtc004 = true; 1426 jjtree.openNodeScope(jjtn004); 1427 try { 1428 UnaryExpression(); 1429 } catch (Throwable jjte004) { 1430 if (jjtc004) { 1431 jjtree.clearNodeScope(jjtn004); 1432 jjtc004 = false; 1433 } else { 1434 jjtree.popNode(); 1435 } 1436 if (jjte004 instanceof RuntimeException ) { 1437 { 1438 if (true) 1439 throw (RuntimeException ) jjte004; 1440 } 1441 } 1442 if (jjte004 instanceof ParseException) { 1443 { 1444 if (true) 1445 throw (ParseException) jjte004; 1446 } 1447 } 1448 { 1449 if (true) 1450 throw (Error ) jjte004; 1451 } 1452 } finally { 1453 if (jjtc004) { 1454 jjtree.closeNodeScope(jjtn004, 2); 1455 } 1456 } 1457 break; 1458 case 41: 1459 jj_consume_token(41); 1460 ASTModNode jjtn005 = new ASTModNode(this, JJTMODNODE); 1461 boolean jjtc005 = true; 1462 jjtree.openNodeScope(jjtn005); 1463 try { 1464 UnaryExpression(); 1465 } catch (Throwable jjte005) { 1466 if (jjtc005) { 1467 jjtree.clearNodeScope(jjtn005); 1468 jjtc005 = false; 1469 } else { 1470 jjtree.popNode(); 1471 } 1472 if (jjte005 instanceof RuntimeException ) { 1473 { 1474 if (true) 1475 throw (RuntimeException ) jjte005; 1476 } 1477 } 1478 if (jjte005 instanceof ParseException) { 1479 { 1480 if (true) 1481 throw (ParseException) jjte005; 1482 } 1483 } 1484 { 1485 if (true) 1486 throw (Error ) jjte005; 1487 } 1488 } finally { 1489 if (jjtc005) { 1490 jjtree.closeNodeScope(jjtn005, 2); 1491 } 1492 } 1493 break; 1494 default: 1495 jj_la1[18] = jj_gen; 1496 jj_consume_token(-1); 1497 throw new ParseException(); 1498 } 1499 } 1500 } 1501 1502 final public void UnaryExpression() throws ParseException { 1503 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1504 case 36: 1505 jj_consume_token(36); 1506 ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(this, JJTUNARYMINUSNODE); 1507 boolean jjtc001 = true; 1508 jjtree.openNodeScope(jjtn001); 1509 try { 1510 UnaryExpression(); 1511 } catch (Throwable jjte001) { 1512 if (jjtc001) { 1513 jjtree.clearNodeScope(jjtn001); 1514 jjtc001 = false; 1515 } else { 1516 jjtree.popNode(); 1517 } 1518 if (jjte001 instanceof RuntimeException ) { 1519 { 1520 if (true) 1521 throw (RuntimeException ) jjte001; 1522 } 1523 } 1524 if (jjte001 instanceof ParseException) { 1525 { 1526 if (true) 1527 throw (ParseException) jjte001; 1528 } 1529 } 1530 { 1531 if (true) 1532 throw (Error ) jjte001; 1533 } 1534 } finally { 1535 if (jjtc001) { 1536 jjtree.closeNodeScope(jjtn001, 1); 1537 } 1538 } 1539 break; 1540 case 42: 1541 jj_consume_token(42); 1542 ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(this, JJTBITWISECOMPLNODE); 1543 boolean jjtc002 = true; 1544 jjtree.openNodeScope(jjtn002); 1545 try { 1546 UnaryExpression(); 1547 } catch (Throwable jjte002) { 1548 if (jjtc002) { 1549 jjtree.clearNodeScope(jjtn002); 1550 jjtc002 = false; 1551 } else { 1552 jjtree.popNode(); 1553 } 1554 if (jjte002 instanceof RuntimeException ) { 1555 { 1556 if (true) 1557 throw (RuntimeException ) jjte002; 1558 } 1559 } 1560 if (jjte002 instanceof ParseException) { 1561 { 1562 if (true) 1563 throw (ParseException) jjte002; 1564 } 1565 } 1566 { 1567 if (true) 1568 throw (Error ) jjte002; 1569 } 1570 } finally { 1571 if (jjtc002) { 1572 jjtree.closeNodeScope(jjtn002, 1); 1573 } 1574 } 1575 break; 1576 case 43: 1577 jj_consume_token(43); 1578 ASTNotNode jjtn003 = new ASTNotNode(this, JJTNOTNODE); 1579 boolean jjtc003 = true; 1580 jjtree.openNodeScope(jjtn003); 1581 try { 1582 UnaryExpression(); 1583 } catch (Throwable jjte003) { 1584 if (jjtc003) { 1585 jjtree.clearNodeScope(jjtn003); 1586 jjtc003 = false; 1587 } else { 1588 jjtree.popNode(); 1589 } 1590 if (jjte003 instanceof RuntimeException ) { 1591 { 1592 if (true) 1593 throw (RuntimeException ) jjte003; 1594 } 1595 } 1596 if (jjte003 instanceof ParseException) { 1597 { 1598 if (true) 1599 throw (ParseException) jjte003; 1600 } 1601 } 1602 { 1603 if (true) 1604 throw (Error ) jjte003; 1605 } 1606 } finally { 1607 if (jjtc003) { 1608 jjtree.closeNodeScope(jjtn003, 1); 1609 } 1610 } 1611 break; 1612 case 44: 1613 jj_consume_token(44); 1614 ASTNotNode jjtn004 = new ASTNotNode(this, JJTNOTNODE); 1615 boolean jjtc004 = true; 1616 jjtree.openNodeScope(jjtn004); 1617 try { 1618 UnaryExpression(); 1619 } catch (Throwable jjte004) { 1620 if (jjtc004) { 1621 jjtree.clearNodeScope(jjtn004); 1622 jjtc004 = false; 1623 } else { 1624 jjtree.popNode(); 1625 } 1626 if (jjte004 instanceof RuntimeException ) { 1627 { 1628 if (true) 1629 throw (RuntimeException ) jjte004; 1630 } 1631 } 1632 if (jjte004 instanceof ParseException) { 1633 { 1634 if (true) 1635 throw (ParseException) jjte004; 1636 } 1637 } 1638 { 1639 if (true) 1640 throw (Error ) jjte004; 1641 } 1642 } finally { 1643 if (jjtc004) { 1644 jjtree.closeNodeScope(jjtn004, 1); 1645 } 1646 } 1647 break; 1648 case INTEGER_LITERAL: 1649 case FLOAT_LITERAL: 1650 case 11: 1651 case 12: 1652 case 14: 1653 case 45: 1654 case 46: 1655 case 47: 1656 case IDENTIFIER: 1657 case STRING_LITERAL: 1658 PrimaryExpression(); 1659 break; 1660 default: 1661 jj_la1[19] = jj_gen; 1662 jj_consume_token(-1); 1663 throw new ParseException(); 1664 } 1665 } 1666 1667 final public void PrimaryExpression() throws ParseException { 1668 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1669 case INTEGER_LITERAL: 1670 case FLOAT_LITERAL: 1671 case 45: 1672 case 46: 1673 case 47: 1674 case STRING_LITERAL: 1675 Literal(); 1676 break; 1677 case IDENTIFIER: 1678 Reference(); 1679 break; 1680 case 12: 1681 jj_consume_token(12); 1682 Expression(); 1683 jj_consume_token(13); 1684 break; 1685 case 11: 1686 EmptyFunction(); 1687 break; 1688 case 14: 1689 SizeFunction(); 1690 break; 1691 default: 1692 jj_la1[20] = jj_gen; 1693 jj_consume_token(-1); 1694 throw new ParseException(); 1695 } 1696 } 1697 1698 final public void Literal() throws ParseException { 1699 Token t; 1700 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1701 case INTEGER_LITERAL: 1702 IntegerLiteral(); 1703 break; 1704 case FLOAT_LITERAL: 1705 FloatLiteral(); 1706 break; 1707 case 46: 1708 case 47: 1709 BooleanLiteral(); 1710 break; 1711 case STRING_LITERAL: 1712 StringLiteral(); 1713 break; 1714 case 45: 1715 NullLiteral(); 1716 break; 1717 default: 1718 jj_la1[21] = jj_gen; 1719 jj_consume_token(-1); 1720 throw new ParseException(); 1721 } 1722 } 1723 1724 final public void NullLiteral() throws ParseException { 1725 1726 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL); 1727 boolean jjtc000 = true; 1728 jjtree.openNodeScope(jjtn000); 1729 try { 1730 jj_consume_token(45); 1731 } finally { 1732 if (jjtc000) { 1733 jjtree.closeNodeScope(jjtn000, true); 1734 } 1735 } 1736 } 1737 1738 final public void BooleanLiteral() throws ParseException { 1739 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1740 case 46: 1741 ASTTrueNode jjtn001 = new ASTTrueNode(this, JJTTRUENODE); 1742 boolean jjtc001 = true; 1743 jjtree.openNodeScope(jjtn001); 1744 try { 1745 jj_consume_token(46); 1746 } finally { 1747 if (jjtc001) { 1748 jjtree.closeNodeScope(jjtn001, true); 1749 } 1750 } 1751 break; 1752 case 47: 1753 ASTFalseNode jjtn002 = new ASTFalseNode(this, JJTFALSENODE); 1754 boolean jjtc002 = true; 1755 jjtree.openNodeScope(jjtn002); 1756 try { 1757 jj_consume_token(47); 1758 } finally { 1759 if (jjtc002) { 1760 jjtree.closeNodeScope(jjtn002, true); 1761 } 1762 } 1763 break; 1764 default: 1765 jj_la1[22] = jj_gen; 1766 jj_consume_token(-1); 1767 throw new ParseException(); 1768 } 1769 } 1770 1771 final public void IntegerLiteral() throws ParseException { 1772 1773 ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL); 1774 boolean jjtc000 = true; 1775 jjtree.openNodeScope(jjtn000); 1776 Token t; 1777 try { 1778 t = jj_consume_token(INTEGER_LITERAL); 1779 jjtree.closeNodeScope(jjtn000, true); 1780 jjtc000 = false; 1781 jjtn000.val = Integer.valueOf(t.image); 1782 } finally { 1783 if (jjtc000) { 1784 jjtree.closeNodeScope(jjtn000, true); 1785 } 1786 } 1787 } 1788 1789 final public void FloatLiteral() throws ParseException { 1790 1791 ASTFloatLiteral jjtn000 = new ASTFloatLiteral(this, JJTFLOATLITERAL); 1792 boolean jjtc000 = true; 1793 jjtree.openNodeScope(jjtn000); 1794 Token t; 1795 try { 1796 t = jj_consume_token(FLOAT_LITERAL); 1797 jjtree.closeNodeScope(jjtn000, true); 1798 jjtc000 = false; 1799 jjtn000.val = Float.valueOf(t.image); 1800 } finally { 1801 if (jjtc000) { 1802 jjtree.closeNodeScope(jjtn000, true); 1803 } 1804 } 1805 } 1806 1807 final public void StringLiteral() throws ParseException { 1808 1809 ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL); 1810 boolean jjtc000 = true; 1811 jjtree.openNodeScope(jjtn000); 1812 Token t; 1813 try { 1814 t = jj_consume_token(STRING_LITERAL); 1815 jjtree.closeNodeScope(jjtn000, true); 1816 jjtc000 = false; 1817 jjtn000.literal = t.image.substring(1, t.image.length() - 1); 1818 } finally { 1819 if (jjtc000) { 1820 jjtree.closeNodeScope(jjtn000, true); 1821 } 1822 } 1823 } 1824 1825 1828 final public void Statement() throws ParseException { 1829 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1830 case 48: 1831 jj_consume_token(48); 1832 break; 1833 case 9: 1834 Block(); 1835 break; 1836 default: 1837 jj_la1[23] = jj_gen; 1838 if (jj_2_2(2147483647)) { 1839 ReferenceExpression(); 1840 } else if (jj_2_3(2147483647)) { 1841 StatementExpression(); 1842 } else { 1843 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 1844 case INTEGER_LITERAL: 1845 case FLOAT_LITERAL: 1846 case 11: 1847 case 12: 1848 case 14: 1849 case 36: 1850 case 42: 1851 case 43: 1852 case 44: 1853 case 45: 1854 case 46: 1855 case 47: 1856 case IDENTIFIER: 1857 case STRING_LITERAL: 1858 ExpressionExpression(); 1859 break; 1860 case 49: 1861 IfStatement(); 1862 break; 1863 case 52: 1864 ForeachStatement(); 1865 break; 1866 case 51: 1867 WhileStatement(); 1868 break; 1869 default: 1870 jj_la1[24] = jj_gen; 1871 jj_consume_token(-1); 1872 throw new ParseException(); 1873 } 1874 } 1875 } 1876 } 1877 1878 final public void ExpressionExpression() throws ParseException { 1879 1880 ASTExpressionExpression jjtn000 = new ASTExpressionExpression(this, JJTEXPRESSIONEXPRESSION); 1881 boolean jjtc000 = true; 1882 jjtree.openNodeScope(jjtn000); 1883 try { 1884 Expression(); 1885 jj_consume_token(48); 1886 } catch (Throwable jjte000) { 1887 if (jjtc000) { 1888 jjtree.clearNodeScope(jjtn000); 1889 jjtc000 = false; 1890 } else { 1891 jjtree.popNode(); 1892 } 1893 if (jjte000 instanceof RuntimeException ) { 1894 { 1895 if (true) 1896 throw (RuntimeException ) jjte000; 1897 } 1898 } 1899 if (jjte000 instanceof ParseException) { 1900 { 1901 if (true) 1902 throw (ParseException) jjte000; 1903 } 1904 } 1905 { 1906 if (true) 1907 throw (Error ) jjte000; 1908 } 1909 } finally { 1910 if (jjtc000) { 1911 jjtree.closeNodeScope(jjtn000, true); 1912 } 1913 } 1914 } 1915 1916 final public void StatementExpression() throws ParseException { 1917 1918 ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION); 1919 boolean jjtc000 = true; 1920 jjtree.openNodeScope(jjtn000); 1921 try { 1922 Assignment(); 1923 jj_consume_token(48); 1924 } catch (Throwable jjte000) { 1925 if (jjtc000) { 1926 jjtree.clearNodeScope(jjtn000); 1927 jjtc000 = false; 1928 } else { 1929 jjtree.popNode(); 1930 } 1931 if (jjte000 instanceof RuntimeException ) { 1932 { 1933 if (true) 1934 throw (RuntimeException ) jjte000; 1935 } 1936 } 1937 if (jjte000 instanceof ParseException) { 1938 { 1939 if (true) 1940 throw (ParseException) jjte000; 1941 } 1942 } 1943 { 1944 if (true) 1945 throw (Error ) jjte000; 1946 } 1947 } finally { 1948 if (jjtc000) { 1949 jjtree.closeNodeScope(jjtn000, true); 1950 } 1951 } 1952 } 1953 1954 final public void ReferenceExpression() throws ParseException { 1955 1956 ASTReferenceExpression jjtn000 = new ASTReferenceExpression(this, JJTREFERENCEEXPRESSION); 1957 boolean jjtc000 = true; 1958 jjtree.openNodeScope(jjtn000); 1959 try { 1960 Reference(); 1961 jj_consume_token(48); 1962 } catch (Throwable jjte000) { 1963 if (jjtc000) { 1964 jjtree.clearNodeScope(jjtn000); 1965 jjtc000 = false; 1966 } else { 1967 jjtree.popNode(); 1968 } 1969 if (jjte000 instanceof RuntimeException ) { 1970 { 1971 if (true) 1972 throw (RuntimeException ) jjte000; 1973 } 1974 } 1975 if (jjte000 instanceof ParseException) { 1976 { 1977 if (true) 1978 throw (ParseException) jjte000; 1979 } 1980 } 1981 { 1982 if (true) 1983 throw (Error ) jjte000; 1984 } 1985 } finally { 1986 if (jjtc000) { 1987 jjtree.closeNodeScope(jjtn000, true); 1988 } 1989 } 1990 } 1991 1992 final public void IfStatement() throws ParseException { 1993 1994 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT); 1995 boolean jjtc000 = true; 1996 jjtree.openNodeScope(jjtn000); 1997 try { 1998 jj_consume_token(49); 1999 jj_consume_token(12); 2000 Expression(); 2001 jj_consume_token(13); 2002 Statement(); 2003 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2004 case 50: 2005 jj_consume_token(50); 2006 Statement(); 2007 break; 2008 default: 2009 jj_la1[25] = jj_gen; 2010 ; 2011 } 2012 } catch (Throwable jjte000) { 2013 if (jjtc000) { 2014 jjtree.clearNodeScope(jjtn000); 2015 jjtc000 = false; 2016 } else { 2017 jjtree.popNode(); 2018 } 2019 if (jjte000 instanceof RuntimeException ) { 2020 { 2021 if (true) 2022 throw (RuntimeException ) jjte000; 2023 } 2024 } 2025 if (jjte000 instanceof ParseException) { 2026 { 2027 if (true) 2028 throw (ParseException) jjte000; 2029 } 2030 } 2031 { 2032 if (true) 2033 throw (Error ) jjte000; 2034 } 2035 } finally { 2036 if (jjtc000) { 2037 jjtree.closeNodeScope(jjtn000, true); 2038 } 2039 } 2040 } 2041 2042 final public void WhileStatement() throws ParseException { 2043 2044 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT); 2045 boolean jjtc000 = true; 2046 jjtree.openNodeScope(jjtn000); 2047 try { 2048 jj_consume_token(51); 2049 jj_consume_token(12); 2050 Expression(); 2051 jj_consume_token(13); 2052 Statement(); 2053 } catch (Throwable jjte000) { 2054 if (jjtc000) { 2055 jjtree.clearNodeScope(jjtn000); 2056 jjtc000 = false; 2057 } else { 2058 jjtree.popNode(); 2059 } 2060 if (jjte000 instanceof RuntimeException ) { 2061 { 2062 if (true) 2063 throw (RuntimeException ) jjte000; 2064 } 2065 } 2066 if (jjte000 instanceof ParseException) { 2067 { 2068 if (true) 2069 throw (ParseException) jjte000; 2070 } 2071 } 2072 { 2073 if (true) 2074 throw (Error ) jjte000; 2075 } 2076 } finally { 2077 if (jjtc000) { 2078 jjtree.closeNodeScope(jjtn000, true); 2079 } 2080 } 2081 } 2082 2083 final public void ForeachStatement() throws ParseException { 2084 2085 ASTForeachStatement jjtn000 = new ASTForeachStatement(this, JJTFOREACHSTATEMENT); 2086 boolean jjtc000 = true; 2087 jjtree.openNodeScope(jjtn000); 2088 try { 2089 jj_consume_token(52); 2090 jj_consume_token(12); 2091 Reference(); 2092 jj_consume_token(53); 2093 Reference(); 2094 jj_consume_token(13); 2095 Statement(); 2096 } catch (Throwable jjte000) { 2097 if (jjtc000) { 2098 jjtree.clearNodeScope(jjtn000); 2099 jjtc000 = false; 2100 } else { 2101 jjtree.popNode(); 2102 } 2103 if (jjte000 instanceof RuntimeException ) { 2104 { 2105 if (true) 2106 throw (RuntimeException ) jjte000; 2107 } 2108 } 2109 if (jjte000 instanceof ParseException) { 2110 { 2111 if (true) 2112 throw (ParseException) jjte000; 2113 } 2114 } 2115 { 2116 if (true) 2117 throw (Error ) jjte000; 2118 } 2119 } finally { 2120 if (jjtc000) { 2121 jjtree.closeNodeScope(jjtn000, true); 2122 } 2123 } 2124 } 2125 2126 final public void Method() throws ParseException { 2127 2128 ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD); 2129 boolean jjtc000 = true; 2130 jjtree.openNodeScope(jjtn000); 2131 try { 2132 Identifier(); 2133 jj_consume_token(12); 2134 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2135 case INTEGER_LITERAL: 2136 case FLOAT_LITERAL: 2137 case 11: 2138 case 12: 2139 case 14: 2140 case 36: 2141 case 42: 2142 case 43: 2143 case 44: 2144 case 45: 2145 case 46: 2146 case 47: 2147 case IDENTIFIER: 2148 case STRING_LITERAL: 2149 Parameter(); 2150 label_12: while (true) { 2151 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2152 case 54: 2153 ; 2154 break; 2155 default: 2156 jj_la1[26] = jj_gen; 2157 break label_12; 2158 } 2159 jj_consume_token(54); 2160 Parameter(); 2161 } 2162 break; 2163 default: 2164 jj_la1[27] = jj_gen; 2165 ; 2166 } 2167 jj_consume_token(13); 2168 } catch (Throwable jjte000) { 2169 if (jjtc000) { 2170 jjtree.clearNodeScope(jjtn000); 2171 jjtc000 = false; 2172 } else { 2173 jjtree.popNode(); 2174 } 2175 if (jjte000 instanceof RuntimeException ) { 2176 { 2177 if (true) 2178 throw (RuntimeException ) jjte000; 2179 } 2180 } 2181 if (jjte000 instanceof ParseException) { 2182 { 2183 if (true) 2184 throw (ParseException) jjte000; 2185 } 2186 } 2187 { 2188 if (true) 2189 throw (Error ) jjte000; 2190 } 2191 } finally { 2192 if (jjtc000) { 2193 jjtree.closeNodeScope(jjtn000, true); 2194 } 2195 } 2196 } 2197 2198 final public void ArrayAccess() throws ParseException { 2199 2200 ASTArrayAccess jjtn000 = new ASTArrayAccess(this, JJTARRAYACCESS); 2201 boolean jjtc000 = true; 2202 jjtree.openNodeScope(jjtn000); 2203 try { 2204 Identifier(); 2205 label_13: while (true) { 2206 jj_consume_token(55); 2207 if (jj_2_4(3)) { 2208 Expression(); 2209 } else { 2210 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2211 case INTEGER_LITERAL: 2212 IntegerLiteral(); 2213 break; 2214 case IDENTIFIER: 2215 Reference(); 2216 break; 2217 default: 2218 jj_la1[28] = jj_gen; 2219 jj_consume_token(-1); 2220 throw new ParseException(); 2221 } 2222 } 2223 jj_consume_token(56); 2224 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2225 case 55: 2226 ; 2227 break; 2228 default: 2229 jj_la1[29] = jj_gen; 2230 break label_13; 2231 } 2232 } 2233 } catch (Throwable jjte000) { 2234 if (jjtc000) { 2235 jjtree.clearNodeScope(jjtn000); 2236 jjtc000 = false; 2237 } else { 2238 jjtree.popNode(); 2239 } 2240 if (jjte000 instanceof RuntimeException ) { 2241 { 2242 if (true) 2243 throw (RuntimeException ) jjte000; 2244 } 2245 } 2246 if (jjte000 instanceof ParseException) { 2247 { 2248 if (true) 2249 throw (ParseException) jjte000; 2250 } 2251 } 2252 { 2253 if (true) 2254 throw (Error ) jjte000; 2255 } 2256 } finally { 2257 if (jjtc000) { 2258 jjtree.closeNodeScope(jjtn000, true); 2259 } 2260 } 2261 } 2262 2263 final public void SizeMethod() throws ParseException { 2264 2265 ASTSizeMethod jjtn000 = new ASTSizeMethod(this, JJTSIZEMETHOD); 2266 boolean jjtc000 = true; 2267 jjtree.openNodeScope(jjtn000); 2268 try { 2269 jj_consume_token(14); 2270 jj_consume_token(12); 2271 jj_consume_token(13); 2272 } finally { 2273 if (jjtc000) { 2274 jjtree.closeNodeScope(jjtn000, true); 2275 } 2276 } 2277 } 2278 2279 final public void Reference() throws ParseException { 2280 2281 ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE); 2282 boolean jjtc000 = true; 2283 jjtree.openNodeScope(jjtn000); 2284 try { 2285 if (jj_2_5(2147483647)) { 2286 ArrayAccess(); 2287 } else { 2288 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2289 case IDENTIFIER: 2290 Identifier(); 2291 break; 2292 default: 2293 jj_la1[30] = jj_gen; 2294 jj_consume_token(-1); 2295 throw new ParseException(); 2296 } 2297 } 2298 label_14: while (true) { 2299 if (jj_2_6(2)) { 2300 ; 2301 } else { 2302 break label_14; 2303 } 2304 jj_consume_token(57); 2305 if (jj_2_8(2147483647)) { 2306 ArrayAccess(); 2307 } else { 2308 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2309 case INTEGER_LITERAL: 2310 case 14: 2311 case IDENTIFIER: 2312 if (jj_2_7(3)) { 2313 Method(); 2314 } else { 2315 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2316 case 14: 2317 SizeMethod(); 2318 break; 2319 case IDENTIFIER: 2320 Identifier(); 2321 break; 2322 case INTEGER_LITERAL: 2323 IntegerLiteral(); 2324 break; 2325 default: 2326 jj_la1[31] = jj_gen; 2327 jj_consume_token(-1); 2328 throw new ParseException(); 2329 } 2330 } 2331 break; 2332 default: 2333 jj_la1[32] = jj_gen; 2334 jj_consume_token(-1); 2335 throw new ParseException(); 2336 } 2337 } 2338 } 2339 } catch (Throwable jjte000) { 2340 if (jjtc000) { 2341 jjtree.clearNodeScope(jjtn000); 2342 jjtc000 = false; 2343 } else { 2344 jjtree.popNode(); 2345 } 2346 if (jjte000 instanceof RuntimeException ) { 2347 { 2348 if (true) 2349 throw (RuntimeException ) jjte000; 2350 } 2351 } 2352 if (jjte000 instanceof ParseException) { 2353 { 2354 if (true) 2355 throw (ParseException) jjte000; 2356 } 2357 } 2358 { 2359 if (true) 2360 throw (Error ) jjte000; 2361 } 2362 } finally { 2363 if (jjtc000) { 2364 jjtree.closeNodeScope(jjtn000, true); 2365 } 2366 } 2367 } 2368 2369 final public void Parameter() throws ParseException { 2370 if (jj_2_9(3)) { 2371 Expression(); 2372 } else { 2373 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { 2374 case INTEGER_LITERAL: 2375 case FLOAT_LITERAL: 2376 case 45: 2377 case 46: 2378 case 47: 2379 case STRING_LITERAL: 2380 Literal(); 2381 break; 2382 case IDENTIFIER: 2383 Reference(); 2384 break; 2385 default: 2386 jj_la1[33] = jj_gen; 2387 jj_consume_token(-1); 2388 throw new ParseException(); 2389 } 2390 } 2391 } 2392 2393 final private boolean jj_2_1(int xla) { 2394 jj_la = xla; 2395 jj_lastpos = jj_scanpos = token; 2396 boolean retval = !jj_3_1(); 2397 jj_save(0, xla); 2398 return retval; 2399 } 2400 2401 final private boolean jj_2_2(int xla) { 2402 jj_la = xla; 2403 jj_lastpos = jj_scanpos = token; 2404 boolean retval = !jj_3_2(); 2405 jj_save(1, xla); 2406 return retval; 2407 } 2408 2409 final private boolean jj_2_3(int xla) { 2410 jj_la = xla; 2411 jj_lastpos = jj_scanpos = token; 2412 boolean retval = !jj_3_3(); 2413 jj_save(2, xla); 2414 return retval; 2415 } 2416 2417 final private boolean jj_2_4(int xla) { 2418 jj_la = xla; 2419 jj_lastpos = jj_scanpos = token; 2420 boolean retval = !jj_3_4(); 2421 jj_save(3, xla); 2422 return retval; 2423 } 2424 2425 final private boolean jj_2_5(int xla) { 2426 jj_la = xla; 2427 jj_lastpos = jj_scanpos = token; 2428 boolean retval = !jj_3_5(); 2429 jj_save(4, xla); 2430 return retval; 2431 } 2432 2433 final private boolean jj_2_6(int xla) { 2434 jj_la = xla; 2435 jj_lastpos = jj_scanpos = token; 2436 boolean retval = !jj_3_6(); 2437 jj_save(5, xla); 2438 return retval; 2439 } 2440 2441 final private boolean jj_2_7(int xla) { 2442 jj_la = xla; 2443 jj_lastpos = jj_scanpos = token; 2444 boolean retval = !jj_3_7(); 2445 jj_save(6, xla); 2446 return retval; 2447 } 2448 2449 final private boolean jj_2_8(int xla) { 2450 jj_la = xla; 2451 jj_lastpos = jj_scanpos = token; 2452 boolean retval = !jj_3_8(); 2453 jj_save(7, xla); 2454 return retval; 2455 } 2456 2457 final private boolean jj_2_9(int xla) { 2458 jj_la = xla; 2459 jj_lastpos = jj_scanpos = token; 2460 boolean retval = !jj_3_9(); 2461 jj_save(8, xla); 2462 return retval; 2463 } 2464 2465 final private boolean jj_3R_71() { 2466 if (jj_scan_token(17)) 2467 return true; 2468 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2469 return false; 2470 if (jj_3R_58()) 2471 return true; 2472 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2473 return false; 2474 return false; 2475 } 2476 2477 final private boolean jj_3R_59() { 2478 Token xsp; 2479 xsp = jj_scanpos; 2480 if (jj_3R_70()) { 2481 jj_scanpos = xsp; 2482 if (jj_3R_71()) 2483 return true; 2484 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2485 return false; 2486 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2487 return false; 2488 return false; 2489 } 2490 2491 final private boolean jj_3R_70() { 2492 if (jj_scan_token(16)) 2493 return true; 2494 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2495 return false; 2496 if (jj_3R_58()) 2497 return true; 2498 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2499 return false; 2500 return false; 2501 } 2502 2503 final private boolean jj_3R_64() { 2504 if (jj_scan_token(STRING_LITERAL)) 2505 return true; 2506 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2507 return false; 2508 return false; 2509 } 2510 2511 final private boolean jj_3R_47() { 2512 if (jj_3R_58()) 2513 return true; 2514 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2515 return false; 2516 Token xsp; 2517 while (true) { 2518 xsp = jj_scanpos; 2519 if (jj_3R_59()) { 2520 jj_scanpos = xsp; 2521 break; 2522 } 2523 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2524 return false; 2525 } 2526 return false; 2527 } 2528 2529 final private boolean jj_3_1() { 2530 if (jj_3R_15()) 2531 return true; 2532 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2533 return false; 2534 if (jj_scan_token(15)) 2535 return true; 2536 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2537 return false; 2538 return false; 2539 } 2540 2541 final private boolean jj_3R_46() { 2542 if (jj_3R_15()) 2543 return true; 2544 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2545 return false; 2546 if (jj_scan_token(15)) 2547 return true; 2548 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2549 return false; 2550 if (jj_3R_17()) 2551 return true; 2552 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2553 return false; 2554 return false; 2555 } 2556 2557 final private boolean jj_3R_34() { 2558 if (jj_3R_18()) 2559 return true; 2560 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2561 return false; 2562 return false; 2563 } 2564 2565 final private boolean jj_3R_62() { 2566 if (jj_scan_token(FLOAT_LITERAL)) 2567 return true; 2568 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2569 return false; 2570 return false; 2571 } 2572 2573 final private boolean jj_3R_36() { 2574 if (jj_3R_47()) 2575 return true; 2576 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2577 return false; 2578 return false; 2579 } 2580 2581 final private boolean jj_3R_35() { 2582 if (jj_3R_46()) 2583 return true; 2584 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2585 return false; 2586 return false; 2587 } 2588 2589 final private boolean jj_3R_17() { 2590 Token xsp; 2591 xsp = jj_scanpos; 2592 if (jj_3R_35()) { 2593 jj_scanpos = xsp; 2594 if (jj_3R_36()) 2595 return true; 2596 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2597 return false; 2598 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2599 return false; 2600 return false; 2601 } 2602 2603 final private boolean jj_3R_56() { 2604 if (jj_scan_token(12)) 2605 return true; 2606 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2607 return false; 2608 if (jj_3R_16()) 2609 return true; 2610 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2611 return false; 2612 if (jj_scan_token(13)) 2613 return true; 2614 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2615 return false; 2616 return false; 2617 } 2618 2619 final private boolean jj_3R_37() { 2620 if (jj_scan_token(INTEGER_LITERAL)) 2621 return true; 2622 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2623 return false; 2624 return false; 2625 } 2626 2627 final private boolean jj_3R_18() { 2628 if (jj_scan_token(IDENTIFIER)) 2629 return true; 2630 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2631 return false; 2632 return false; 2633 } 2634 2635 final private boolean jj_3R_73() { 2636 if (jj_scan_token(47)) 2637 return true; 2638 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2639 return false; 2640 return false; 2641 } 2642 2643 final private boolean jj_3R_63() { 2644 Token xsp; 2645 xsp = jj_scanpos; 2646 if (jj_3R_72()) { 2647 jj_scanpos = xsp; 2648 if (jj_3R_73()) 2649 return true; 2650 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2651 return false; 2652 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2653 return false; 2654 return false; 2655 } 2656 2657 final private boolean jj_3R_72() { 2658 if (jj_scan_token(46)) 2659 return true; 2660 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2661 return false; 2662 return false; 2663 } 2664 2665 final private boolean jj_3R_45() { 2666 if (jj_scan_token(14)) 2667 return true; 2668 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2669 return false; 2670 if (jj_scan_token(12)) 2671 return true; 2672 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2673 return false; 2674 if (jj_3R_16()) 2675 return true; 2676 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2677 return false; 2678 if (jj_scan_token(13)) 2679 return true; 2680 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2681 return false; 2682 return false; 2683 } 2684 2685 final private boolean jj_3R_27() { 2686 if (jj_3R_16()) 2687 return true; 2688 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2689 return false; 2690 return false; 2691 } 2692 2693 final private boolean jj_3R_65() { 2694 if (jj_scan_token(45)) 2695 return true; 2696 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2697 return false; 2698 return false; 2699 } 2700 2701 final private boolean jj_3R_55() { 2702 if (jj_3R_16()) 2703 return true; 2704 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2705 return false; 2706 return false; 2707 } 2708 2709 final private boolean jj_3R_41() { 2710 if (jj_3R_37()) 2711 return true; 2712 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2713 return false; 2714 return false; 2715 } 2716 2717 final private boolean jj_3R_44() { 2718 if (jj_scan_token(11)) 2719 return true; 2720 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2721 return false; 2722 Token xsp; 2723 xsp = jj_scanpos; 2724 if (jj_3R_55()) { 2725 jj_scanpos = xsp; 2726 if (jj_3R_56()) 2727 return true; 2728 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2729 return false; 2730 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2731 return false; 2732 return false; 2733 } 2734 2735 final private boolean jj_3R_21() { 2736 if (jj_3R_16()) 2737 return true; 2738 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2739 return false; 2740 return false; 2741 } 2742 2743 final private boolean jj_3R_54() { 2744 if (jj_3R_65()) 2745 return true; 2746 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2747 return false; 2748 return false; 2749 } 2750 2751 final private boolean jj_3R_53() { 2752 if (jj_3R_64()) 2753 return true; 2754 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2755 return false; 2756 return false; 2757 } 2758 2759 final private boolean jj_3R_67() { 2760 if (jj_3R_16()) 2761 return true; 2762 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2763 return false; 2764 return false; 2765 } 2766 2767 final private boolean jj_3R_52() { 2768 if (jj_3R_63()) 2769 return true; 2770 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2771 return false; 2772 return false; 2773 } 2774 2775 final private boolean jj_3R_61() { 2776 if (jj_3R_16()) 2777 return true; 2778 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2779 return false; 2780 return false; 2781 } 2782 2783 final private boolean jj_3R_51() { 2784 if (jj_3R_62()) 2785 return true; 2786 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2787 return false; 2788 return false; 2789 } 2790 2791 final private boolean jj_3R_43() { 2792 Token xsp; 2793 xsp = jj_scanpos; 2794 if (jj_3R_50()) { 2795 jj_scanpos = xsp; 2796 if (jj_3R_51()) { 2797 jj_scanpos = xsp; 2798 if (jj_3R_52()) { 2799 jj_scanpos = xsp; 2800 if (jj_3R_53()) { 2801 jj_scanpos = xsp; 2802 if (jj_3R_54()) 2803 return true; 2804 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2805 return false; 2806 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2807 return false; 2808 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2809 return false; 2810 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2811 return false; 2812 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2813 return false; 2814 return false; 2815 } 2816 2817 final private boolean jj_3R_50() { 2818 if (jj_3R_37()) 2819 return true; 2820 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2821 return false; 2822 return false; 2823 } 2824 2825 final private boolean jj_3R_26() { 2826 if (jj_3R_37()) 2827 return true; 2828 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2829 return false; 2830 return false; 2831 } 2832 2833 final private boolean jj_3R_40() { 2834 if (jj_3R_18()) 2835 return true; 2836 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2837 return false; 2838 return false; 2839 } 2840 2841 final private boolean jj_3R_20() { 2842 if (jj_3R_37()) 2843 return true; 2844 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2845 return false; 2846 return false; 2847 } 2848 2849 final private boolean jj_3R_32() { 2850 if (jj_3R_45()) 2851 return true; 2852 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2853 return false; 2854 return false; 2855 } 2856 2857 final private boolean jj_3R_60() { 2858 if (jj_3R_43()) 2859 return true; 2860 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2861 return false; 2862 return false; 2863 } 2864 2865 final private boolean jj_3R_31() { 2866 if (jj_3R_44()) 2867 return true; 2868 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2869 return false; 2870 return false; 2871 } 2872 2873 final private boolean jj_3R_30() { 2874 if (jj_scan_token(12)) 2875 return true; 2876 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2877 return false; 2878 if (jj_3R_17()) 2879 return true; 2880 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2881 return false; 2882 if (jj_scan_token(13)) 2883 return true; 2884 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2885 return false; 2886 return false; 2887 } 2888 2889 final private boolean jj_3R_66() { 2890 if (jj_3R_37()) 2891 return true; 2892 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2893 return false; 2894 return false; 2895 } 2896 2897 final private boolean jj_3R_29() { 2898 if (jj_3R_16()) 2899 return true; 2900 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2901 return false; 2902 return false; 2903 } 2904 2905 final private boolean jj_3R_28() { 2906 if (jj_3R_43()) 2907 return true; 2908 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2909 return false; 2910 return false; 2911 } 2912 2913 final private boolean jj_3R_15() { 2914 Token xsp; 2915 xsp = jj_scanpos; 2916 if (jj_3R_28()) { 2917 jj_scanpos = xsp; 2918 if (jj_3R_29()) { 2919 jj_scanpos = xsp; 2920 if (jj_3R_30()) { 2921 jj_scanpos = xsp; 2922 if (jj_3R_31()) { 2923 jj_scanpos = xsp; 2924 if (jj_3R_32()) 2925 return true; 2926 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2927 return false; 2928 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2929 return false; 2930 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2931 return false; 2932 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2933 return false; 2934 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 2935 return false; 2936 return false; 2937 } 2938 2939 final private boolean jj_3R_25() { 2940 if (jj_3R_17()) 2941 return true; 2942 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2943 return false; 2944 return false; 2945 } 2946 2947 final private boolean jj_3R_39() { 2948 if (jj_3R_48()) 2949 return true; 2950 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2951 return false; 2952 return false; 2953 } 2954 2955 final private boolean jj_3R_109() { 2956 if (jj_3R_15()) 2957 return true; 2958 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2959 return false; 2960 return false; 2961 } 2962 2963 final private boolean jj_3R_19() { 2964 if (jj_3R_17()) 2965 return true; 2966 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2967 return false; 2968 return false; 2969 } 2970 2971 final private boolean jj_3R_108() { 2972 if (jj_scan_token(44)) 2973 return true; 2974 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2975 return false; 2976 if (jj_3R_101()) 2977 return true; 2978 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2979 return false; 2980 return false; 2981 } 2982 2983 final private boolean jj_3R_107() { 2984 if (jj_scan_token(43)) 2985 return true; 2986 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2987 return false; 2988 if (jj_3R_101()) 2989 return true; 2990 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2991 return false; 2992 return false; 2993 } 2994 2995 final private boolean jj_3R_106() { 2996 if (jj_scan_token(42)) 2997 return true; 2998 if (jj_la == 0 && jj_scanpos == jj_lastpos) 2999 return false; 3000 if (jj_3R_101()) 3001 return true; 3002 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3003 return false; 3004 return false; 3005 } 3006 3007 final private boolean jj_3R_105() { 3008 if (jj_scan_token(36)) 3009 return true; 3010 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3011 return false; 3012 if (jj_3R_101()) 3013 return true; 3014 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3015 return false; 3016 return false; 3017 } 3018 3019 final private boolean jj_3R_101() { 3020 Token xsp; 3021 xsp = jj_scanpos; 3022 if (jj_3R_105()) { 3023 jj_scanpos = xsp; 3024 if (jj_3R_106()) { 3025 jj_scanpos = xsp; 3026 if (jj_3R_107()) { 3027 jj_scanpos = xsp; 3028 if (jj_3R_108()) { 3029 jj_scanpos = xsp; 3030 if (jj_3R_109()) 3031 return true; 3032 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3033 return false; 3034 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3035 return false; 3036 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3037 return false; 3038 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3039 return false; 3040 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3041 return false; 3042 return false; 3043 } 3044 3045 final private boolean jj_3R_78() { 3046 if (jj_scan_token(54)) 3047 return true; 3048 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3049 return false; 3050 if (jj_3R_49()) 3051 return true; 3052 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3053 return false; 3054 return false; 3055 } 3056 3057 final private boolean jj_3R_114() { 3058 if (jj_scan_token(41)) 3059 return true; 3060 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3061 return false; 3062 if (jj_3R_101()) 3063 return true; 3064 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3065 return false; 3066 return false; 3067 } 3068 3069 final private boolean jj_3_8() { 3070 if (jj_3R_18()) 3071 return true; 3072 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3073 return false; 3074 if (jj_scan_token(55)) 3075 return true; 3076 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3077 return false; 3078 Token xsp; 3079 xsp = jj_scanpos; 3080 if (jj_3R_25()) { 3081 jj_scanpos = xsp; 3082 if (jj_3R_26()) { 3083 jj_scanpos = xsp; 3084 if (jj_3R_27()) 3085 return true; 3086 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3087 return false; 3088 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3089 return false; 3090 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3091 return false; 3092 if (jj_scan_token(56)) 3093 return true; 3094 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3095 return false; 3096 return false; 3097 } 3098 3099 final private boolean jj_3R_113() { 3100 if (jj_scan_token(40)) 3101 return true; 3102 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3103 return false; 3104 if (jj_3R_101()) 3105 return true; 3106 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3107 return false; 3108 return false; 3109 } 3110 3111 final private boolean jj_3_9() { 3112 if (jj_3R_17()) 3113 return true; 3114 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3115 return false; 3116 return false; 3117 } 3118 3119 final private boolean jj_3R_49() { 3120 Token xsp; 3121 xsp = jj_scanpos; 3122 if (jj_3_9()) { 3123 jj_scanpos = xsp; 3124 if (jj_3R_60()) { 3125 jj_scanpos = xsp; 3126 if (jj_3R_61()) 3127 return true; 3128 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3129 return false; 3130 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3131 return false; 3132 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3133 return false; 3134 return false; 3135 } 3136 3137 final private boolean jj_3R_112() { 3138 if (jj_scan_token(39)) 3139 return true; 3140 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3141 return false; 3142 if (jj_3R_101()) 3143 return true; 3144 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3145 return false; 3146 return false; 3147 } 3148 3149 final private boolean jj_3_4() { 3150 if (jj_3R_17()) 3151 return true; 3152 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3153 return false; 3154 return false; 3155 } 3156 3157 final private boolean jj_3R_111() { 3158 if (jj_scan_token(38)) 3159 return true; 3160 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3161 return false; 3162 if (jj_3R_101()) 3163 return true; 3164 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3165 return false; 3166 return false; 3167 } 3168 3169 final private boolean jj_3_5() { 3170 if (jj_3R_18()) 3171 return true; 3172 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3173 return false; 3174 if (jj_scan_token(55)) 3175 return true; 3176 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3177 return false; 3178 Token xsp; 3179 xsp = jj_scanpos; 3180 if (jj_3R_19()) { 3181 jj_scanpos = xsp; 3182 if (jj_3R_20()) { 3183 jj_scanpos = xsp; 3184 if (jj_3R_21()) 3185 return true; 3186 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3187 return false; 3188 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3189 return false; 3190 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3191 return false; 3192 if (jj_scan_token(56)) 3193 return true; 3194 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3195 return false; 3196 return false; 3197 } 3198 3199 final private boolean jj_3_7() { 3200 if (jj_3R_24()) 3201 return true; 3202 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3203 return false; 3204 return false; 3205 } 3206 3207 final private boolean jj_3R_110() { 3208 if (jj_scan_token(37)) 3209 return true; 3210 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3211 return false; 3212 if (jj_3R_101()) 3213 return true; 3214 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3215 return false; 3216 return false; 3217 } 3218 3219 final private boolean jj_3R_102() { 3220 Token xsp; 3221 xsp = jj_scanpos; 3222 if (jj_3R_110()) { 3223 jj_scanpos = xsp; 3224 if (jj_3R_111()) { 3225 jj_scanpos = xsp; 3226 if (jj_3R_112()) { 3227 jj_scanpos = xsp; 3228 if (jj_3R_113()) { 3229 jj_scanpos = xsp; 3230 if (jj_3R_114()) 3231 return true; 3232 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3233 return false; 3234 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3235 return false; 3236 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3237 return false; 3238 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3239 return false; 3240 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3241 return false; 3242 return false; 3243 } 3244 3245 final private boolean jj_3R_23() { 3246 Token xsp; 3247 xsp = jj_scanpos; 3248 if (jj_3_7()) { 3249 jj_scanpos = xsp; 3250 if (jj_3R_39()) { 3251 jj_scanpos = xsp; 3252 if (jj_3R_40()) { 3253 jj_scanpos = xsp; 3254 if (jj_3R_41()) 3255 return true; 3256 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3257 return false; 3258 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3259 return false; 3260 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3261 return false; 3262 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3263 return false; 3264 return false; 3265 } 3266 3267 final private boolean jj_3R_22() { 3268 if (jj_3R_38()) 3269 return true; 3270 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3271 return false; 3272 return false; 3273 } 3274 3275 final private boolean jj_3R_57() { 3276 if (jj_scan_token(55)) 3277 return true; 3278 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3279 return false; 3280 Token xsp; 3281 xsp = jj_scanpos; 3282 if (jj_3_4()) { 3283 jj_scanpos = xsp; 3284 if (jj_3R_66()) { 3285 jj_scanpos = xsp; 3286 if (jj_3R_67()) 3287 return true; 3288 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3289 return false; 3290 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3291 return false; 3292 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3293 return false; 3294 if (jj_scan_token(56)) 3295 return true; 3296 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3297 return false; 3298 return false; 3299 } 3300 3301 final private boolean jj_3R_91() { 3302 if (jj_3R_101()) 3303 return true; 3304 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3305 return false; 3306 Token xsp; 3307 while (true) { 3308 xsp = jj_scanpos; 3309 if (jj_3R_102()) { 3310 jj_scanpos = xsp; 3311 break; 3312 } 3313 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3314 return false; 3315 } 3316 return false; 3317 } 3318 3319 final private boolean jj_3R_42() { 3320 if (jj_3R_49()) 3321 return true; 3322 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3323 return false; 3324 Token xsp; 3325 while (true) { 3326 xsp = jj_scanpos; 3327 if (jj_3R_78()) { 3328 jj_scanpos = xsp; 3329 break; 3330 } 3331 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3332 return false; 3333 } 3334 return false; 3335 } 3336 3337 final private boolean jj_3_6() { 3338 if (jj_scan_token(57)) 3339 return true; 3340 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3341 return false; 3342 Token xsp; 3343 xsp = jj_scanpos; 3344 if (jj_3R_22()) { 3345 jj_scanpos = xsp; 3346 if (jj_3R_23()) 3347 return true; 3348 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3349 return false; 3350 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3351 return false; 3352 return false; 3353 } 3354 3355 final private boolean jj_3R_33() { 3356 if (jj_3R_38()) 3357 return true; 3358 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3359 return false; 3360 return false; 3361 } 3362 3363 final private boolean jj_3R_48() { 3364 if (jj_scan_token(14)) 3365 return true; 3366 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3367 return false; 3368 if (jj_scan_token(12)) 3369 return true; 3370 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3371 return false; 3372 if (jj_scan_token(13)) 3373 return true; 3374 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3375 return false; 3376 return false; 3377 } 3378 3379 final private boolean jj_3R_104() { 3380 if (jj_scan_token(36)) 3381 return true; 3382 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3383 return false; 3384 if (jj_3R_91()) 3385 return true; 3386 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3387 return false; 3388 return false; 3389 } 3390 3391 final private boolean jj_3R_16() { 3392 Token xsp; 3393 xsp = jj_scanpos; 3394 if (jj_3R_33()) { 3395 jj_scanpos = xsp; 3396 if (jj_3R_34()) 3397 return true; 3398 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3399 return false; 3400 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3401 return false; 3402 while (true) { 3403 xsp = jj_scanpos; 3404 if (jj_3_6()) { 3405 jj_scanpos = xsp; 3406 break; 3407 } 3408 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3409 return false; 3410 } 3411 return false; 3412 } 3413 3414 final private boolean jj_3R_103() { 3415 if (jj_scan_token(35)) 3416 return true; 3417 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3418 return false; 3419 if (jj_3R_91()) 3420 return true; 3421 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3422 return false; 3423 return false; 3424 } 3425 3426 final private boolean jj_3R_92() { 3427 Token xsp; 3428 xsp = jj_scanpos; 3429 if (jj_3R_103()) { 3430 jj_scanpos = xsp; 3431 if (jj_3R_104()) 3432 return true; 3433 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3434 return false; 3435 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3436 return false; 3437 return false; 3438 } 3439 3440 final private boolean jj_3R_85() { 3441 if (jj_3R_91()) 3442 return true; 3443 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3444 return false; 3445 Token xsp; 3446 while (true) { 3447 xsp = jj_scanpos; 3448 if (jj_3R_92()) { 3449 jj_scanpos = xsp; 3450 break; 3451 } 3452 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3453 return false; 3454 } 3455 return false; 3456 } 3457 3458 final private boolean jj_3R_38() { 3459 if (jj_3R_18()) 3460 return true; 3461 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3462 return false; 3463 Token xsp; 3464 if (jj_3R_57()) 3465 return true; 3466 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3467 return false; 3468 while (true) { 3469 xsp = jj_scanpos; 3470 if (jj_3R_57()) { 3471 jj_scanpos = xsp; 3472 break; 3473 } 3474 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3475 return false; 3476 } 3477 return false; 3478 } 3479 3480 final private boolean jj_3R_100() { 3481 if (jj_scan_token(34)) 3482 return true; 3483 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3484 return false; 3485 if (jj_3R_85()) 3486 return true; 3487 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3488 return false; 3489 return false; 3490 } 3491 3492 final private boolean jj_3R_99() { 3493 if (jj_scan_token(33)) 3494 return true; 3495 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3496 return false; 3497 if (jj_3R_85()) 3498 return true; 3499 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3500 return false; 3501 return false; 3502 } 3503 3504 final private boolean jj_3R_24() { 3505 if (jj_3R_18()) 3506 return true; 3507 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3508 return false; 3509 if (jj_scan_token(12)) 3510 return true; 3511 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3512 return false; 3513 Token xsp; 3514 xsp = jj_scanpos; 3515 if (jj_3R_42()) 3516 jj_scanpos = xsp; 3517 else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3518 return false; 3519 if (jj_scan_token(13)) 3520 return true; 3521 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3522 return false; 3523 return false; 3524 } 3525 3526 final private boolean jj_3R_98() { 3527 if (jj_scan_token(32)) 3528 return true; 3529 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3530 return false; 3531 if (jj_3R_85()) 3532 return true; 3533 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3534 return false; 3535 return false; 3536 } 3537 3538 final private boolean jj_3R_97() { 3539 if (jj_scan_token(31)) 3540 return true; 3541 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3542 return false; 3543 if (jj_3R_85()) 3544 return true; 3545 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3546 return false; 3547 return false; 3548 } 3549 3550 final private boolean jj_3R_96() { 3551 if (jj_scan_token(30)) 3552 return true; 3553 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3554 return false; 3555 if (jj_3R_85()) 3556 return true; 3557 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3558 return false; 3559 return false; 3560 } 3561 3562 final private boolean jj_3R_95() { 3563 if (jj_scan_token(29)) 3564 return true; 3565 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3566 return false; 3567 if (jj_3R_85()) 3568 return true; 3569 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3570 return false; 3571 return false; 3572 } 3573 3574 final private boolean jj_3R_94() { 3575 if (jj_scan_token(28)) 3576 return true; 3577 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3578 return false; 3579 if (jj_3R_85()) 3580 return true; 3581 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3582 return false; 3583 return false; 3584 } 3585 3586 final private boolean jj_3R_93() { 3587 if (jj_scan_token(27)) 3588 return true; 3589 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3590 return false; 3591 if (jj_3R_85()) 3592 return true; 3593 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3594 return false; 3595 return false; 3596 } 3597 3598 final private boolean jj_3R_86() { 3599 Token xsp; 3600 xsp = jj_scanpos; 3601 if (jj_3R_93()) { 3602 jj_scanpos = xsp; 3603 if (jj_3R_94()) { 3604 jj_scanpos = xsp; 3605 if (jj_3R_95()) { 3606 jj_scanpos = xsp; 3607 if (jj_3R_96()) { 3608 jj_scanpos = xsp; 3609 if (jj_3R_97()) { 3610 jj_scanpos = xsp; 3611 if (jj_3R_98()) { 3612 jj_scanpos = xsp; 3613 if (jj_3R_99()) { 3614 jj_scanpos = xsp; 3615 if (jj_3R_100()) 3616 return true; 3617 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3618 return false; 3619 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3620 return false; 3621 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3622 return false; 3623 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3624 return false; 3625 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3626 return false; 3627 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3628 return false; 3629 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3630 return false; 3631 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3632 return false; 3633 return false; 3634 } 3635 3636 final private boolean jj_3R_83() { 3637 if (jj_3R_85()) 3638 return true; 3639 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3640 return false; 3641 Token xsp; 3642 while (true) { 3643 xsp = jj_scanpos; 3644 if (jj_3R_86()) { 3645 jj_scanpos = xsp; 3646 break; 3647 } 3648 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3649 return false; 3650 } 3651 return false; 3652 } 3653 3654 final private boolean jj_3R_90() { 3655 if (jj_scan_token(26)) 3656 return true; 3657 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3658 return false; 3659 if (jj_3R_83()) 3660 return true; 3661 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3662 return false; 3663 return false; 3664 } 3665 3666 final private boolean jj_3R_89() { 3667 if (jj_scan_token(25)) 3668 return true; 3669 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3670 return false; 3671 if (jj_3R_83()) 3672 return true; 3673 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3674 return false; 3675 return false; 3676 } 3677 3678 final private boolean jj_3R_88() { 3679 if (jj_scan_token(24)) 3680 return true; 3681 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3682 return false; 3683 if (jj_3R_83()) 3684 return true; 3685 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3686 return false; 3687 return false; 3688 } 3689 3690 final private boolean jj_3R_87() { 3691 if (jj_scan_token(23)) 3692 return true; 3693 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3694 return false; 3695 if (jj_3R_83()) 3696 return true; 3697 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3698 return false; 3699 return false; 3700 } 3701 3702 final private boolean jj_3R_84() { 3703 Token xsp; 3704 xsp = jj_scanpos; 3705 if (jj_3R_87()) { 3706 jj_scanpos = xsp; 3707 if (jj_3R_88()) { 3708 jj_scanpos = xsp; 3709 if (jj_3R_89()) { 3710 jj_scanpos = xsp; 3711 if (jj_3R_90()) 3712 return true; 3713 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3714 return false; 3715 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3716 return false; 3717 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3718 return false; 3719 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3720 return false; 3721 return false; 3722 } 3723 3724 final private boolean jj_3R_81() { 3725 if (jj_3R_83()) 3726 return true; 3727 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3728 return false; 3729 Token xsp; 3730 while (true) { 3731 xsp = jj_scanpos; 3732 if (jj_3R_84()) { 3733 jj_scanpos = xsp; 3734 break; 3735 } 3736 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3737 return false; 3738 } 3739 return false; 3740 } 3741 3742 final private boolean jj_3R_82() { 3743 if (jj_scan_token(22)) 3744 return true; 3745 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3746 return false; 3747 if (jj_3R_81()) 3748 return true; 3749 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3750 return false; 3751 return false; 3752 } 3753 3754 final private boolean jj_3R_79() { 3755 if (jj_3R_81()) 3756 return true; 3757 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3758 return false; 3759 Token xsp; 3760 while (true) { 3761 xsp = jj_scanpos; 3762 if (jj_3R_82()) { 3763 jj_scanpos = xsp; 3764 break; 3765 } 3766 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3767 return false; 3768 } 3769 return false; 3770 } 3771 3772 final private boolean jj_3_3() { 3773 if (jj_3R_15()) 3774 return true; 3775 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3776 return false; 3777 if (jj_scan_token(15)) 3778 return true; 3779 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3780 return false; 3781 return false; 3782 } 3783 3784 final private boolean jj_3_2() { 3785 if (jj_3R_16()) 3786 return true; 3787 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3788 return false; 3789 if (jj_scan_token(48)) 3790 return true; 3791 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3792 return false; 3793 return false; 3794 } 3795 3796 final private boolean jj_3R_80() { 3797 if (jj_scan_token(21)) 3798 return true; 3799 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3800 return false; 3801 if (jj_3R_79()) 3802 return true; 3803 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3804 return false; 3805 return false; 3806 } 3807 3808 final private boolean jj_3R_74() { 3809 if (jj_3R_79()) 3810 return true; 3811 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3812 return false; 3813 Token xsp; 3814 while (true) { 3815 xsp = jj_scanpos; 3816 if (jj_3R_80()) { 3817 jj_scanpos = xsp; 3818 break; 3819 } 3820 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3821 return false; 3822 } 3823 return false; 3824 } 3825 3826 final private boolean jj_3R_75() { 3827 if (jj_scan_token(20)) 3828 return true; 3829 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3830 return false; 3831 if (jj_3R_74()) 3832 return true; 3833 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3834 return false; 3835 return false; 3836 } 3837 3838 final private boolean jj_3R_68() { 3839 if (jj_3R_74()) 3840 return true; 3841 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3842 return false; 3843 Token xsp; 3844 while (true) { 3845 xsp = jj_scanpos; 3846 if (jj_3R_75()) { 3847 jj_scanpos = xsp; 3848 break; 3849 } 3850 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3851 return false; 3852 } 3853 return false; 3854 } 3855 3856 final private boolean jj_3R_77() { 3857 if (jj_scan_token(19)) 3858 return true; 3859 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3860 return false; 3861 if (jj_3R_68()) 3862 return true; 3863 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3864 return false; 3865 return false; 3866 } 3867 3868 final private boolean jj_3R_69() { 3869 Token xsp; 3870 xsp = jj_scanpos; 3871 if (jj_3R_76()) { 3872 jj_scanpos = xsp; 3873 if (jj_3R_77()) 3874 return true; 3875 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3876 return false; 3877 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) 3878 return false; 3879 return false; 3880 } 3881 3882 final private boolean jj_3R_76() { 3883 if (jj_scan_token(18)) 3884 return true; 3885 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3886 return false; 3887 if (jj_3R_68()) 3888 return true; 3889 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3890 return false; 3891 return false; 3892 } 3893 3894 final private boolean jj_3R_58() { 3895 if (jj_3R_68()) 3896 return true; 3897 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3898 return false; 3899 Token xsp; 3900 while (true) { 3901 xsp = jj_scanpos; 3902 if (jj_3R_69()) { 3903 jj_scanpos = xsp; 3904 break; 3905 } 3906 if (jj_la == 0 && jj_scanpos == jj_lastpos) 3907 return false; 3908 } 3909 return false; 3910 } 3911 3912 public ParserTokenManager token_source; 3913 3914 SimpleCharStream jj_input_stream; 3915 3916 public Token token, jj_nt; 3917 3918 private int jj_ntk; 3919 3920 private Token jj_scanpos, jj_lastpos; 3921 3922 private int jj_la; 3923 3924 public boolean lookingAhead = false; 3925 3926 private boolean jj_semLA; 3927 3928 private int jj_gen; 3929 3930 final private int[] jj_la1 = new int[34]; 3931 3932 final private int[] jj_la1_0 = { 0x5b80, 0x5b80, 0x1000, 0x5980, 0x30000, 0x30000, 0xc0000, 0xc0000, 0x100000, 3933 0x200000, 0x400000, 0x7800000, 0x7800000, 0xf8000000, 0xf8000000, 0x0, 0x0, 0x0, 0x0, 0x5980, 0x5980, 0x180, 3934 0x0, 0x200, 0x5980, 0x0, 0x0, 0x5980, 0x80, 0x0, 0x0, 0x4080, 0x4080, 0x180, }; 3935 3936 final private int[] jj_la1_1 = { 0x241bfc10, 0x241bfc10, 0x4000000, 0x2400fc10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 3937 0x0, 0x0, 0x7, 0x7, 0x18, 0x18, 0x3e0, 0x3e0, 0x2400fc10, 0x2400e000, 0x2000e000, 0xc000, 0x10000, 0x241afc10, 3938 0x40000, 0x400000, 0x2400fc10, 0x4000000, 0x800000, 0x4000000, 0x4000000, 0x4000000, 0x2400e000, }; 3939 3940 final private JJCalls[] jj_2_rtns = new JJCalls[9]; 3941 3942 private boolean jj_rescan = false; 3943 3944 private int jj_gc = 0; 3945 3946 public Parser(java.io.InputStream stream) { 3947 jj_input_stream = new SimpleCharStream(stream, 1, 1); 3948 token_source = new ParserTokenManager(jj_input_stream); 3949 token = new Token(); 3950 jj_ntk = -1; 3951 jj_gen = 0; 3952 for (int i = 0; i < 34; i++) 3953 jj_la1[i] = -1; 3954 for (int i = 0; i < jj_2_rtns.length; i++) 3955 jj_2_rtns[i] = new JJCalls(); 3956 } 3957 3958 public void ReInit(java.io.InputStream stream) { 3959 jj_input_stream.ReInit(stream, 1, 1); 3960 token_source.ReInit(jj_input_stream); 3961 token = new Token(); 3962 jj_ntk = -1; 3963 jjtree.reset(); 3964 jj_gen = 0; 3965 for (int i = 0; i < 34; i++) 3966 jj_la1[i] = -1; 3967 for (int i = 0; i < jj_2_rtns.length; i++) 3968 jj_2_rtns[i] = new JJCalls(); 3969 } 3970 3971 public Parser(java.io.Reader stream) { 3972 jj_input_stream = new SimpleCharStream(stream, 1, 1); 3973 token_source = new ParserTokenManager(jj_input_stream); 3974 token = new Token(); 3975 jj_ntk = -1; 3976 jj_gen = 0; 3977 for (int i = 0; i < 34; i++) 3978 jj_la1[i] = -1; 3979 for (int i = 0; i < jj_2_rtns.length; i++) 3980 jj_2_rtns[i] = new JJCalls(); 3981 } 3982 3983 public void ReInit(java.io.Reader stream) { 3984 jj_input_stream.ReInit(stream, 1, 1); 3985 token_source.ReInit(jj_input_stream); 3986 token = new Token(); 3987 jj_ntk = -1; 3988 jjtree.reset(); 3989 jj_gen = 0; 3990 for (int i = 0; i < 34; i++) 3991 jj_la1[i] = -1; 3992 for (int i = 0; i < jj_2_rtns.length; i++) 3993 jj_2_rtns[i] = new JJCalls(); 3994 } 3995 3996 public Parser(ParserTokenManager tm) { 3997 token_source = tm; 3998 token = new Token(); 3999 jj_ntk = -1; 4000 jj_gen = 0; 4001 for (int i = 0; i < 34; i++) 4002 jj_la1[i] = -1; 4003 for (int i = 0; i < jj_2_rtns.length; i++) 4004 jj_2_rtns[i] = new JJCalls(); 4005 } 4006 4007 public void ReInit(ParserTokenManager tm) { 4008 token_source = tm; 4009 token = new Token(); 4010 jj_ntk = -1; 4011 jjtree.reset(); 4012 jj_gen = 0; 4013 for (int i = 0; i < 34; i++) 4014 jj_la1[i] = -1; 4015 for (int i = 0; i < jj_2_rtns.length; i++) 4016 jj_2_rtns[i] = new JJCalls(); 4017 } 4018 4019 final private Token jj_consume_token(int kind) throws ParseException { 4020 Token oldToken; 4021 if ((oldToken = token).next != null) 4022 token = token.next; 4023 else 4024 token = token.next = token_source.getNextToken(); 4025 jj_ntk = -1; 4026 if (token.kind == kind) { 4027 jj_gen++; 4028 if (++jj_gc > 100) { 4029 jj_gc = 0; 4030 for (int i = 0; i < jj_2_rtns.length; i++) { 4031 JJCalls c = jj_2_rtns[i]; 4032 while (c != null) { 4033 if (c.gen < jj_gen) 4034 c.first = null; 4035 c = c.next; 4036 } 4037 } 4038 } 4039 return token; 4040 } 4041 token = oldToken; 4042 jj_kind = kind; 4043 throw generateParseException(); 4044 } 4045 4046 final private boolean jj_scan_token(int kind) { 4047 if (jj_scanpos == jj_lastpos) { 4048 jj_la--; 4049 if (jj_scanpos.next == null) { 4050 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); 4051 } else { 4052 jj_lastpos = jj_scanpos = jj_scanpos.next; 4053 } 4054 } else { 4055 jj_scanpos = jj_scanpos.next; 4056 } 4057 if (jj_rescan) { 4058 int i = 0; 4059 Token tok = token; 4060 while (tok != null && tok != jj_scanpos) { 4061 i++; 4062 tok = tok.next; 4063 } 4064 if (tok != null) 4065 jj_add_error_token(kind, i); 4066 } 4067 return (jj_scanpos.kind != kind); 4068 } 4069 4070 final public Token getNextToken() { 4071 if (token.next != null) 4072 token = token.next; 4073 else 4074 token = token.next = token_source.getNextToken(); 4075 jj_ntk = -1; 4076 jj_gen++; 4077 return token; 4078 } 4079 4080 final public Token getToken(int index) { 4081 Token t = lookingAhead ? jj_scanpos : token; 4082 for (int i = 0; i < index; i++) { 4083 if (t.next != null) 4084 t = t.next; 4085 else 4086 t = t.next = token_source.getNextToken(); 4087 } 4088 return t; 4089 } 4090 4091 final private int jj_ntk() { 4092 if ((jj_nt = token.next) == null) 4093 return (jj_ntk = (token.next = token_source.getNextToken()).kind); 4094 else 4095 return (jj_ntk = jj_nt.kind); 4096 } 4097 4098 private java.util.Vector jj_expentries = new java.util.Vector (); 4099 4100 private int[] jj_expentry; 4101 4102 private int jj_kind = -1; 4103 4104 private int[] jj_lasttokens = new int[100]; 4105 4106 private int jj_endpos; 4107 4108 private void jj_add_error_token(int kind, int pos) { 4109 if (pos >= 100) 4110 return; 4111 if (pos == jj_endpos + 1) { 4112 jj_lasttokens[jj_endpos++] = kind; 4113 } else if (jj_endpos != 0) { 4114 jj_expentry = new int[jj_endpos]; 4115 for (int i = 0; i < jj_endpos; i++) { 4116 jj_expentry[i] = jj_lasttokens[i]; 4117 } 4118 boolean exists = false; 4119 for (java.util.Enumeration enumeration = jj_expentries.elements(); enumeration.hasMoreElements();) { 4120 int[] oldentry = (int[]) (enumeration.nextElement()); 4121 if (oldentry.length == jj_expentry.length) { 4122 exists = true; 4123 for (int i = 0; i < jj_expentry.length; i++) { 4124 if (oldentry[i] != jj_expentry[i]) { 4125 exists = false; 4126 break; 4127 } 4128 } 4129 if (exists) 4130 break; 4131 } 4132 } 4133 if (!exists) 4134 jj_expentries.addElement(jj_expentry); 4135 if (pos != 0) 4136 jj_lasttokens[(jj_endpos = pos) - 1] = kind; 4137 } 4138 } 4139 4140 final public ParseException generateParseException() { 4141 jj_expentries.removeAllElements(); 4142 boolean[] la1tokens = new boolean[62]; 4143 for (int i = 0; i < 62; i++) { 4144 la1tokens[i] = false; 4145 } 4146 if (jj_kind >= 0) { 4147 la1tokens[jj_kind] = true; 4148 jj_kind = -1; 4149 } 4150 for (int i = 0; i < 34; i++) { 4151 if (jj_la1[i] == jj_gen) { 4152 for (int j = 0; j < 32; j++) { 4153 if ((jj_la1_0[i] & (1 << j)) != 0) { 4154 la1tokens[j] = true; 4155 } 4156 if ((jj_la1_1[i] & (1 << j)) != 0) { 4157 la1tokens[32 + j] = true; 4158 } 4159 } 4160 } 4161 } 4162 for (int i = 0; i < 62; i++) { 4163 if (la1tokens[i]) { 4164 jj_expentry = new int[1]; 4165 jj_expentry[0] = i; 4166 jj_expentries.addElement(jj_expentry); 4167 } 4168 } 4169 jj_endpos = 0; 4170 jj_rescan_token(); 4171 jj_add_error_token(0, 0); 4172 int[][] exptokseq = new int[jj_expentries.size()][]; 4173 for (int i = 0; i < jj_expentries.size(); i++) { 4174 exptokseq[i] = (int[]) jj_expentries.elementAt(i); 4175 } 4176 return new ParseException(token, exptokseq, tokenImage); 4177 } 4178 4179 final public void enable_tracing() { 4180 } 4181 4182 final public void disable_tracing() { 4183 } 4184 4185 final private void jj_rescan_token() { 4186 jj_rescan = true; 4187 for (int i = 0; i < 9; i++) { 4188 JJCalls p = jj_2_rtns[i]; 4189 do { 4190 if (p.gen > jj_gen) { 4191 jj_la = p.arg; 4192 jj_lastpos = jj_scanpos = p.first; 4193 switch (i) { 4194 case 0: 4195 jj_3_1(); 4196 break; 4197 case 1: 4198 jj_3_2(); 4199 break; 4200 case 2: 4201 jj_3_3(); 4202 break; 4203 case 3: 4204 jj_3_4(); 4205 break; 4206 case 4: 4207 jj_3_5(); 4208 break; 4209 case 5: 4210 jj_3_6(); 4211 break; 4212 case 6: 4213 jj_3_7(); 4214 break; 4215 case 7: 4216 jj_3_8(); 4217 break; 4218 case 8: 4219 jj_3_9(); 4220 break; 4221 } 4222 } 4223 p = p.next; 4224 } while (p != null); 4225 } 4226 jj_rescan = false; 4227 } 4228 4229 final private void jj_save(int index, int xla) { 4230 JJCalls p = jj_2_rtns[index]; 4231 while (p.gen > jj_gen) { 4232 if (p.next == null) { 4233 p = p.next = new JJCalls(); 4234 break; 4235 } 4236 p = p.next; 4237 } 4238 p.gen = jj_gen + xla - jj_la; 4239 p.first = token; 4240 p.arg = xla; 4241 } 4242 4243 static final class JJCalls { 4244 int gen; 4245 4246 Token first; 4247 4248 int arg; 4249 4250 JJCalls next; 4251 } 4252 4253} 4254 | Popular Tags |