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