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