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