001/* Generated By:JJTree&JavaCC: Do not edit this line. PtParserTokenManager.java */ 002/* 003 Copyright (c) 1998-2015 The Regents of the University of California. 004 All rights reserved. 005 Permission is hereby granted, without written agreement and without 006 license or royalty fees, to use, copy, modify, and distribute this 007 software and its documentation for any purpose, provided that the above 008 copyright notice and the following two paragraphs appear in all copies 009 of this software. 010 011 IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY 012 FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 013 ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF 014 THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF 015 SUCH DAMAGE. 016 017 THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, 018 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 019 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE 020 PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF 021 CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, 022 ENHANCEMENTS, OR MODIFICATIONS. 023 024 PT_COPYRIGHT_VERSION_2 025 COPYRIGHTENDKEY 026 027Created : May 1998 028 */ 029 030package ptolemy.data.expr; 031 032/** Token Manager. */ 033public class PtParserTokenManager implements PtParserConstants { 034 035 /** Debug output. */ 036 public java.io.PrintStream debugStream = System.out; 037 038 /** Set debug output. */ 039 public void setDebugStream(java.io.PrintStream ds) { 040 debugStream = ds; 041 } 042 043 private final int jjStopStringLiteralDfa_5(int pos, long active0) { 044 switch (pos) { 045 case 0: 046 if ((active0 & 0x7000000000000000L) != 0L) { 047 return 0; 048 } 049 return -1; 050 default: 051 return -1; 052 } 053 } 054 055 private final int jjStartNfa_5(int pos, long active0) { 056 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1); 057 } 058 059 private int jjStopAtPos(int pos, int kind) { 060 jjmatchedKind = kind; 061 jjmatchedPos = pos; 062 return pos + 1; 063 } 064 065 private int jjMoveStringLiteralDfa0_5() { 066 switch (curChar) { 067 case 36: 068 jjmatchedKind = 60; 069 return jjMoveStringLiteralDfa1_5(0x6000000000000000L); 070 default: 071 return jjMoveNfa_5(3, 0); 072 } 073 } 074 075 private int jjMoveStringLiteralDfa1_5(long active0) { 076 try { 077 curChar = input_stream.readChar(); 078 } catch (java.io.IOException e) { 079 jjStopStringLiteralDfa_5(0, active0); 080 return 1; 081 } 082 switch (curChar) { 083 case 40: 084 if ((active0 & 0x4000000000000000L) != 0L) { 085 return jjStopAtPos(1, 62); 086 } 087 break; 088 case 123: 089 if ((active0 & 0x2000000000000000L) != 0L) { 090 return jjStopAtPos(1, 61); 091 } 092 break; 093 default: 094 break; 095 } 096 return jjStartNfa_5(0, active0); 097 } 098 099 static final long[] jjbitVec0 = { 0x0L, 0x0L, 0xffffffffffffffffL, 100 0xffffffffffffffffL }; 101 102 private int jjMoveNfa_5(int startState, int curPos) { 103 int startsAt = 0; 104 jjnewStateCnt = 3; 105 int i = 1; 106 jjstateSet[0] = startState; 107 int kind = 0x7fffffff; 108 for (;;) { 109 if (++jjround == 0x7fffffff) { 110 ReInitRounds(); 111 } 112 if (curChar < 64) { 113 long l = 1L << curChar; 114 do { 115 switch (jjstateSet[--i]) { 116 case 3: 117 if ((0xffffffefffffffffL & l) != 0L) { 118 if (kind > 59) { 119 kind = 59; 120 } 121 jjCheckNAddTwoStates(1, 2); 122 } else if (curChar == 36) { 123 jjstateSet[jjnewStateCnt++] = 0; 124 } 125 break; 126 case 0: 127 if (curChar != 36) { 128 break; 129 } 130 if (kind > 59) { 131 kind = 59; 132 } 133 jjCheckNAddTwoStates(1, 2); 134 break; 135 case 1: 136 if (curChar == 36) { 137 jjstateSet[jjnewStateCnt++] = 0; 138 } 139 break; 140 case 2: 141 if ((0xffffffefffffffffL & l) == 0L) { 142 break; 143 } 144 kind = 59; 145 jjCheckNAddTwoStates(1, 2); 146 break; 147 default: 148 break; 149 } 150 } while (i != startsAt); 151 } else if (curChar < 128) { 152 do { 153 switch (jjstateSet[--i]) { 154 case 3: 155 case 2: 156 kind = 59; 157 jjCheckNAddTwoStates(1, 2); 158 break; 159 default: 160 break; 161 } 162 } while (i != startsAt); 163 } else { 164 int i2 = (curChar & 0xff) >> 6; 165 long l2 = 1L << (curChar & 077); 166 do { 167 switch (jjstateSet[--i]) { 168 case 3: 169 case 2: 170 if ((jjbitVec0[i2] & l2) == 0L) { 171 break; 172 } 173 if (kind > 59) { 174 kind = 59; 175 } 176 jjCheckNAddTwoStates(1, 2); 177 break; 178 default: 179 break; 180 } 181 } while (i != startsAt); 182 } 183 if (kind != 0x7fffffff) { 184 jjmatchedKind = kind; 185 jjmatchedPos = curPos; 186 kind = 0x7fffffff; 187 } 188 ++curPos; 189 if ((i = jjnewStateCnt) == (startsAt = 3 190 - (jjnewStateCnt = startsAt))) { 191 return curPos; 192 } 193 try { 194 curChar = input_stream.readChar(); 195 } catch (java.io.IOException e) { 196 return curPos; 197 } 198 } 199 } 200 201 private final int jjStopStringLiteralDfa_0(int pos, long active0) { 202 switch (pos) { 203 case 0: 204 if ((active0 & 0x20000000000000L) != 0L) { 205 jjmatchedKind = 54; 206 return 11; 207 } 208 if ((active0 & 0x800000L) != 0L) { 209 return 84; 210 } 211 return -1; 212 case 1: 213 if ((active0 & 0x20000000000000L) != 0L) { 214 if (jjmatchedPos != 1) { 215 jjmatchedKind = 54; 216 jjmatchedPos = 1; 217 } 218 return 85; 219 } 220 return -1; 221 case 2: 222 if ((active0 & 0x20000000000000L) != 0L) { 223 jjmatchedKind = 54; 224 jjmatchedPos = 2; 225 return 85; 226 } 227 return -1; 228 case 3: 229 if ((active0 & 0x20000000000000L) != 0L) { 230 jjmatchedKind = 54; 231 jjmatchedPos = 3; 232 return 85; 233 } 234 return -1; 235 case 4: 236 if ((active0 & 0x20000000000000L) != 0L) { 237 jjmatchedKind = 54; 238 jjmatchedPos = 4; 239 return 85; 240 } 241 return -1; 242 case 5: 243 if ((active0 & 0x20000000000000L) != 0L) { 244 jjmatchedKind = 54; 245 jjmatchedPos = 5; 246 return 85; 247 } 248 return -1; 249 case 6: 250 if ((active0 & 0x20000000000000L) != 0L) { 251 jjmatchedKind = 54; 252 jjmatchedPos = 6; 253 return 85; 254 } 255 return -1; 256 default: 257 return -1; 258 } 259 } 260 261 private final int jjStartNfa_0(int pos, long active0) { 262 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 263 } 264 265 private int jjMoveStringLiteralDfa0_0() { 266 switch (curChar) { 267 case 33: 268 jjmatchedKind = 36; 269 return jjMoveStringLiteralDfa1_0(0x100000000L); 270 case 35: 271 return jjStopAtPos(0, 40); 272 case 37: 273 return jjStopAtPos(0, 14); 274 case 38: 275 jjmatchedKind = 38; 276 return jjMoveStringLiteralDfa1_0(0x400000000L); 277 case 40: 278 return jjStopAtPos(0, 16); 279 case 41: 280 return jjStopAtPos(0, 17); 281 case 42: 282 return jjStopAtPos(0, 12); 283 case 43: 284 return jjStopAtPos(0, 10); 285 case 44: 286 return jjStopAtPos(0, 22); 287 case 45: 288 return jjStopAtPos(0, 11); 289 case 46: 290 return jjStartNfaWithStates_0(0, 23, 84); 291 case 47: 292 jjmatchedKind = 13; 293 return jjMoveStringLiteralDfa1_0(0x6L); 294 case 58: 295 return jjStopAtPos(0, 24); 296 case 59: 297 return jjStopAtPos(0, 58); 298 case 60: 299 jjmatchedKind = 29; 300 return jjMoveStringLiteralDfa1_0(0x20080000000L); 301 case 61: 302 jjmatchedKind = 57; 303 return jjMoveStringLiteralDfa1_0(0x200000000L); 304 case 62: 305 jjmatchedKind = 28; 306 return jjMoveStringLiteralDfa1_0(0xc0040000000L); 307 case 63: 308 return jjStopAtPos(0, 25); 309 case 91: 310 return jjStopAtPos(0, 20); 311 case 93: 312 return jjStopAtPos(0, 21); 313 case 94: 314 return jjStopAtPos(0, 15); 315 case 102: 316 return jjMoveStringLiteralDfa1_0(0x20000000000000L); 317 case 123: 318 jjmatchedKind = 18; 319 return jjMoveStringLiteralDfa1_0(0x4000000L); 320 case 124: 321 jjmatchedKind = 39; 322 return jjMoveStringLiteralDfa1_0(0x808000000L); 323 case 125: 324 return jjStopAtPos(0, 19); 325 case 126: 326 return jjStopAtPos(0, 37); 327 default: 328 return jjMoveNfa_0(0, 0); 329 } 330 } 331 332 private int jjMoveStringLiteralDfa1_0(long active0) { 333 try { 334 curChar = input_stream.readChar(); 335 } catch (java.io.IOException e) { 336 jjStopStringLiteralDfa_0(0, active0); 337 return 1; 338 } 339 switch (curChar) { 340 case 38: 341 if ((active0 & 0x400000000L) != 0L) { 342 return jjStopAtPos(1, 34); 343 } 344 break; 345 case 42: 346 if ((active0 & 0x4L) != 0L) { 347 return jjStopAtPos(1, 2); 348 } 349 break; 350 case 47: 351 if ((active0 & 0x2L) != 0L) { 352 return jjStopAtPos(1, 1); 353 } 354 break; 355 case 60: 356 if ((active0 & 0x20000000000L) != 0L) { 357 return jjStopAtPos(1, 41); 358 } 359 break; 360 case 61: 361 if ((active0 & 0x40000000L) != 0L) { 362 return jjStopAtPos(1, 30); 363 } else if ((active0 & 0x80000000L) != 0L) { 364 return jjStopAtPos(1, 31); 365 } else if ((active0 & 0x100000000L) != 0L) { 366 return jjStopAtPos(1, 32); 367 } else if ((active0 & 0x200000000L) != 0L) { 368 return jjStopAtPos(1, 33); 369 } 370 break; 371 case 62: 372 if ((active0 & 0x40000000000L) != 0L) { 373 jjmatchedKind = 42; 374 jjmatchedPos = 1; 375 } 376 return jjMoveStringLiteralDfa2_0(active0, 0x80000000000L); 377 case 117: 378 return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L); 379 case 124: 380 if ((active0 & 0x4000000L) != 0L) { 381 return jjStopAtPos(1, 26); 382 } else if ((active0 & 0x800000000L) != 0L) { 383 return jjStopAtPos(1, 35); 384 } 385 break; 386 case 125: 387 if ((active0 & 0x8000000L) != 0L) { 388 return jjStopAtPos(1, 27); 389 } 390 break; 391 default: 392 break; 393 } 394 return jjStartNfa_0(0, active0); 395 } 396 397 private int jjMoveStringLiteralDfa2_0(long old0, long active0) { 398 if (((active0 &= old0)) == 0L) { 399 return jjStartNfa_0(0, old0); 400 } 401 try { 402 curChar = input_stream.readChar(); 403 } catch (java.io.IOException e) { 404 jjStopStringLiteralDfa_0(1, active0); 405 return 2; 406 } 407 switch (curChar) { 408 case 62: 409 if ((active0 & 0x80000000000L) != 0L) { 410 return jjStopAtPos(2, 43); 411 } 412 break; 413 case 110: 414 return jjMoveStringLiteralDfa3_0(active0, 0x20000000000000L); 415 default: 416 break; 417 } 418 return jjStartNfa_0(1, active0); 419 } 420 421 private int jjMoveStringLiteralDfa3_0(long old0, long active0) { 422 if (((active0 &= old0)) == 0L) { 423 return jjStartNfa_0(1, old0); 424 } 425 try { 426 curChar = input_stream.readChar(); 427 } catch (java.io.IOException e) { 428 jjStopStringLiteralDfa_0(2, active0); 429 return 3; 430 } 431 switch (curChar) { 432 case 99: 433 return jjMoveStringLiteralDfa4_0(active0, 0x20000000000000L); 434 default: 435 break; 436 } 437 return jjStartNfa_0(2, active0); 438 } 439 440 private int jjMoveStringLiteralDfa4_0(long old0, long active0) { 441 if (((active0 &= old0)) == 0L) { 442 return jjStartNfa_0(2, old0); 443 } 444 try { 445 curChar = input_stream.readChar(); 446 } catch (java.io.IOException e) { 447 jjStopStringLiteralDfa_0(3, active0); 448 return 4; 449 } 450 switch (curChar) { 451 case 116: 452 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L); 453 default: 454 break; 455 } 456 return jjStartNfa_0(3, active0); 457 } 458 459 private int jjMoveStringLiteralDfa5_0(long old0, long active0) { 460 if (((active0 &= old0)) == 0L) { 461 return jjStartNfa_0(3, old0); 462 } 463 try { 464 curChar = input_stream.readChar(); 465 } catch (java.io.IOException e) { 466 jjStopStringLiteralDfa_0(4, active0); 467 return 5; 468 } 469 switch (curChar) { 470 case 105: 471 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L); 472 default: 473 break; 474 } 475 return jjStartNfa_0(4, active0); 476 } 477 478 private int jjMoveStringLiteralDfa6_0(long old0, long active0) { 479 if (((active0 &= old0)) == 0L) { 480 return jjStartNfa_0(4, old0); 481 } 482 try { 483 curChar = input_stream.readChar(); 484 } catch (java.io.IOException e) { 485 jjStopStringLiteralDfa_0(5, active0); 486 return 6; 487 } 488 switch (curChar) { 489 case 111: 490 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L); 491 default: 492 break; 493 } 494 return jjStartNfa_0(5, active0); 495 } 496 497 private int jjMoveStringLiteralDfa7_0(long old0, long active0) { 498 if (((active0 &= old0)) == 0L) { 499 return jjStartNfa_0(5, old0); 500 } 501 try { 502 curChar = input_stream.readChar(); 503 } catch (java.io.IOException e) { 504 jjStopStringLiteralDfa_0(6, active0); 505 return 7; 506 } 507 switch (curChar) { 508 case 110: 509 if ((active0 & 0x20000000000000L) != 0L) { 510 return jjStartNfaWithStates_0(7, 53, 85); 511 } 512 break; 513 default: 514 break; 515 } 516 return jjStartNfa_0(6, active0); 517 } 518 519 private int jjStartNfaWithStates_0(int pos, int kind, int state) { 520 jjmatchedKind = kind; 521 jjmatchedPos = pos; 522 try { 523 curChar = input_stream.readChar(); 524 } catch (java.io.IOException e) { 525 return pos + 1; 526 } 527 return jjMoveNfa_0(state, pos + 1); 528 } 529 530 private int jjMoveNfa_0(int startState, int curPos) { 531 int startsAt = 0; 532 jjnewStateCnt = 84; 533 int i = 1; 534 jjstateSet[0] = startState; 535 int kind = 0x7fffffff; 536 for (;;) { 537 if (++jjround == 0x7fffffff) { 538 ReInitRounds(); 539 } 540 if (curChar < 64) { 541 long l = 1L << curChar; 542 do { 543 switch (jjstateSet[--i]) { 544 case 85: 545 if ((0x3ff001000000000L & l) != 0L) { 546 if (kind > 54) { 547 kind = 54; 548 } 549 jjCheckNAddTwoStates(14, 16); 550 } else if (curChar == 58) { 551 jjstateSet[jjnewStateCnt++] = 15; 552 } 553 break; 554 case 84: 555 if ((0x3ff000000000000L & l) != 0L) { 556 if (kind > 51) { 557 kind = 51; 558 } 559 jjCheckNAddStates(0, 2); 560 } 561 if ((0x3ff000000000000L & l) != 0L) { 562 if (kind > 50) { 563 kind = 50; 564 } 565 jjCheckNAddStates(3, 5); 566 } 567 break; 568 case 11: 569 if ((0x3ff001000000000L & l) != 0L) { 570 if (kind > 54) { 571 kind = 54; 572 } 573 jjCheckNAddTwoStates(14, 16); 574 } else if (curChar == 58) { 575 jjstateSet[jjnewStateCnt++] = 15; 576 } 577 break; 578 case 0: 579 if ((0x3ff000000000000L & l) != 0L) { 580 jjCheckNAddStates(6, 19); 581 } else if (curChar == 46) { 582 jjCheckNAddTwoStates(45, 50); 583 } else if (curChar == 39) { 584 if (kind > 56) { 585 kind = 56; 586 } 587 jjCheckNAddTwoStates(23, 24); 588 } else if (curChar == 34) { 589 if (kind > 56) { 590 kind = 56; 591 } 592 jjCheckNAddStates(20, 22); 593 } 594 if ((0x3fe000000000000L & l) != 0L) { 595 if (kind > 44) { 596 kind = 44; 597 } 598 jjCheckNAddStates(23, 25); 599 } else if (curChar == 48) { 600 if (kind > 44) { 601 kind = 44; 602 } 603 jjCheckNAddStates(26, 29); 604 } 605 break; 606 case 1: 607 if ((0x3ff000000000000L & l) == 0L) { 608 break; 609 } 610 if (kind > 44) { 611 kind = 44; 612 } 613 jjCheckNAddStates(23, 25); 614 break; 615 case 14: 616 if ((0x3ff001000000000L & l) == 0L) { 617 break; 618 } 619 if (kind > 54) { 620 kind = 54; 621 } 622 jjCheckNAddTwoStates(14, 16); 623 break; 624 case 15: 625 if (curChar != 58) { 626 break; 627 } 628 if (kind > 54) { 629 kind = 54; 630 } 631 jjCheckNAddTwoStates(14, 16); 632 break; 633 case 16: 634 if (curChar == 58) { 635 jjstateSet[jjnewStateCnt++] = 15; 636 } 637 break; 638 case 17: 639 case 18: 640 if (curChar != 34) { 641 break; 642 } 643 if (kind > 56) { 644 kind = 56; 645 } 646 jjCheckNAddStates(20, 22); 647 break; 648 case 20: 649 if ((0xfffffffbffffffffL & l) == 0L) { 650 break; 651 } 652 if (kind > 56) { 653 kind = 56; 654 } 655 jjCheckNAddStates(20, 22); 656 break; 657 case 21: 658 if (curChar == 34 && kind > 56) { 659 kind = 56; 660 } 661 break; 662 case 22: 663 if (curChar != 39) { 664 break; 665 } 666 if (kind > 56) { 667 kind = 56; 668 } 669 jjCheckNAddTwoStates(23, 24); 670 break; 671 case 23: 672 if ((0xffffff7fffffffffL & l) == 0L) { 673 break; 674 } 675 if (kind > 56) { 676 kind = 56; 677 } 678 jjCheckNAddTwoStates(23, 24); 679 break; 680 case 24: 681 if (curChar == 39 && kind > 56) { 682 kind = 56; 683 } 684 break; 685 case 38: 686 if (curChar != 48) { 687 break; 688 } 689 if (kind > 44) { 690 kind = 44; 691 } 692 jjCheckNAddStates(26, 29); 693 break; 694 case 40: 695 if ((0x3ff000000000000L & l) == 0L) { 696 break; 697 } 698 if (kind > 44) { 699 kind = 44; 700 } 701 jjCheckNAddStates(30, 32); 702 break; 703 case 42: 704 if ((0xff000000000000L & l) == 0L) { 705 break; 706 } 707 if (kind > 44) { 708 kind = 44; 709 } 710 jjCheckNAddStates(33, 35); 711 break; 712 case 44: 713 if (curChar == 46) { 714 jjCheckNAddTwoStates(45, 50); 715 } 716 break; 717 case 45: 718 if ((0x3ff000000000000L & l) == 0L) { 719 break; 720 } 721 if (kind > 50) { 722 kind = 50; 723 } 724 jjCheckNAddStates(3, 5); 725 break; 726 case 47: 727 if ((0x280000000000L & l) != 0L) { 728 jjCheckNAdd(48); 729 } 730 break; 731 case 48: 732 if ((0x3ff000000000000L & l) == 0L) { 733 break; 734 } 735 if (kind > 50) { 736 kind = 50; 737 } 738 jjCheckNAddTwoStates(48, 49); 739 break; 740 case 50: 741 if ((0x3ff000000000000L & l) == 0L) { 742 break; 743 } 744 if (kind > 51) { 745 kind = 51; 746 } 747 jjCheckNAddStates(0, 2); 748 break; 749 case 52: 750 if ((0x280000000000L & l) != 0L) { 751 jjCheckNAdd(53); 752 } 753 break; 754 case 53: 755 if ((0x3ff000000000000L & l) == 0L) { 756 break; 757 } 758 if (kind > 51) { 759 kind = 51; 760 } 761 jjCheckNAddTwoStates(53, 54); 762 break; 763 case 55: 764 if ((0x3ff000000000000L & l) != 0L) { 765 jjCheckNAddStates(6, 19); 766 } 767 break; 768 case 56: 769 if ((0x3ff000000000000L & l) != 0L) { 770 jjCheckNAddTwoStates(56, 57); 771 } 772 break; 773 case 57: 774 if (curChar == 46) { 775 jjCheckNAdd(58); 776 } 777 break; 778 case 58: 779 if ((0x3ff000000000000L & l) == 0L) { 780 break; 781 } 782 if (kind > 50) { 783 kind = 50; 784 } 785 jjCheckNAddStates(36, 38); 786 break; 787 case 60: 788 if ((0x280000000000L & l) != 0L) { 789 jjCheckNAdd(61); 790 } 791 break; 792 case 61: 793 if ((0x3ff000000000000L & l) == 0L) { 794 break; 795 } 796 if (kind > 50) { 797 kind = 50; 798 } 799 jjCheckNAddTwoStates(61, 49); 800 break; 801 case 62: 802 if ((0x3ff000000000000L & l) != 0L) { 803 jjCheckNAddTwoStates(62, 63); 804 } 805 break; 806 case 64: 807 if ((0x280000000000L & l) != 0L) { 808 jjCheckNAdd(65); 809 } 810 break; 811 case 65: 812 if ((0x3ff000000000000L & l) == 0L) { 813 break; 814 } 815 if (kind > 50) { 816 kind = 50; 817 } 818 jjCheckNAddTwoStates(65, 49); 819 break; 820 case 66: 821 if ((0x3ff000000000000L & l) != 0L) { 822 jjCheckNAddStates(39, 41); 823 } 824 break; 825 case 68: 826 if ((0x280000000000L & l) != 0L) { 827 jjCheckNAdd(69); 828 } 829 break; 830 case 69: 831 if ((0x3ff000000000000L & l) != 0L) { 832 jjCheckNAddTwoStates(69, 49); 833 } 834 break; 835 case 70: 836 if ((0x3ff000000000000L & l) != 0L) { 837 jjCheckNAddTwoStates(70, 71); 838 } 839 break; 840 case 71: 841 if (curChar == 46) { 842 jjCheckNAdd(72); 843 } 844 break; 845 case 72: 846 if ((0x3ff000000000000L & l) == 0L) { 847 break; 848 } 849 if (kind > 51) { 850 kind = 51; 851 } 852 jjCheckNAddStates(42, 44); 853 break; 854 case 74: 855 if ((0x280000000000L & l) != 0L) { 856 jjCheckNAdd(75); 857 } 858 break; 859 case 75: 860 if ((0x3ff000000000000L & l) == 0L) { 861 break; 862 } 863 if (kind > 51) { 864 kind = 51; 865 } 866 jjCheckNAddTwoStates(75, 54); 867 break; 868 case 76: 869 if ((0x3ff000000000000L & l) != 0L) { 870 jjCheckNAddTwoStates(76, 77); 871 } 872 break; 873 case 78: 874 if ((0x280000000000L & l) != 0L) { 875 jjCheckNAdd(79); 876 } 877 break; 878 case 79: 879 if ((0x3ff000000000000L & l) == 0L) { 880 break; 881 } 882 if (kind > 51) { 883 kind = 51; 884 } 885 jjCheckNAddTwoStates(79, 54); 886 break; 887 case 80: 888 if ((0x3ff000000000000L & l) != 0L) { 889 jjCheckNAddStates(45, 47); 890 } 891 break; 892 case 82: 893 if ((0x280000000000L & l) != 0L) { 894 jjCheckNAdd(83); 895 } 896 break; 897 case 83: 898 if ((0x3ff000000000000L & l) != 0L) { 899 jjCheckNAddTwoStates(83, 54); 900 } 901 break; 902 default: 903 break; 904 } 905 } while (i != startsAt); 906 } else if (curChar < 128) { 907 long l = 1L << (curChar & 077); 908 do { 909 switch (jjstateSet[--i]) { 910 case 85: 911 if ((0x7fffffe87ffffffL & l) != 0L) { 912 if (kind > 54) { 913 kind = 54; 914 } 915 jjCheckNAddTwoStates(14, 16); 916 } 917 if ((0x7fffffe87fffffeL & l) != 0L) { 918 if (kind > 54) { 919 kind = 54; 920 } 921 jjCheckNAddStates(48, 50); 922 } 923 break; 924 case 11: 925 if ((0x7fffffe87ffffffL & l) != 0L) { 926 if (kind > 54) { 927 kind = 54; 928 } 929 jjCheckNAddTwoStates(14, 16); 930 } 931 if ((0x7fffffe87fffffeL & l) != 0L) { 932 if (kind > 54) { 933 kind = 54; 934 } 935 jjCheckNAddStates(48, 50); 936 } 937 if (curChar == 97) { 938 jjstateSet[jjnewStateCnt++] = 10; 939 } 940 break; 941 case 0: 942 if ((0x7fffffe87fffffeL & l) != 0L) { 943 if (kind > 54) { 944 kind = 54; 945 } 946 jjCheckNAddStates(48, 50); 947 } 948 if (curChar == 70) { 949 jjAddStates(51, 52); 950 } else if (curChar == 84) { 951 jjAddStates(53, 54); 952 } else if (curChar == 102) { 953 jjstateSet[jjnewStateCnt++] = 11; 954 } else if (curChar == 116) { 955 jjstateSet[jjnewStateCnt++] = 7; 956 } 957 break; 958 case 2: 959 if ((0x8100000081000L & l) != 0L && kind > 44) { 960 kind = 44; 961 } 962 break; 963 case 3: 964 case 41: 965 case 43: 966 if ((0x20000000200000L & l) != 0L) { 967 jjCheckNAdd(4); 968 } 969 break; 970 case 4: 971 if ((0x400000004L & l) != 0L && kind > 44) { 972 kind = 44; 973 } 974 break; 975 case 5: 976 if (curChar == 101 && kind > 52) { 977 kind = 52; 978 } 979 break; 980 case 6: 981 case 29: 982 if (curChar == 117) { 983 jjCheckNAdd(5); 984 } 985 break; 986 case 7: 987 if (curChar == 114) { 988 jjstateSet[jjnewStateCnt++] = 6; 989 } 990 break; 991 case 8: 992 if (curChar == 116) { 993 jjstateSet[jjnewStateCnt++] = 7; 994 } 995 break; 996 case 9: 997 case 35: 998 if (curChar == 115) { 999 jjCheckNAdd(5); 1000 } 1001 break; 1002 case 10: 1003 if (curChar == 108) { 1004 jjstateSet[jjnewStateCnt++] = 9; 1005 } 1006 break; 1007 case 12: 1008 if (curChar == 102) { 1009 jjstateSet[jjnewStateCnt++] = 11; 1010 } 1011 break; 1012 case 13: 1013 if ((0x7fffffe87fffffeL & l) == 0L) { 1014 break; 1015 } 1016 if (kind > 54) { 1017 kind = 54; 1018 } 1019 jjCheckNAddStates(48, 50); 1020 break; 1021 case 14: 1022 if ((0x7fffffe87ffffffL & l) == 0L) { 1023 break; 1024 } 1025 if (kind > 54) { 1026 kind = 54; 1027 } 1028 jjCheckNAddTwoStates(14, 16); 1029 break; 1030 case 19: 1031 if (curChar == 92) { 1032 jjstateSet[jjnewStateCnt++] = 18; 1033 } 1034 break; 1035 case 20: 1036 if (kind > 56) { 1037 kind = 56; 1038 } 1039 jjAddStates(20, 22); 1040 break; 1041 case 23: 1042 if (kind > 56) { 1043 kind = 56; 1044 } 1045 jjAddStates(55, 56); 1046 break; 1047 case 25: 1048 if (curChar == 84) { 1049 jjAddStates(53, 54); 1050 } 1051 break; 1052 case 26: 1053 if (curChar == 69 && kind > 52) { 1054 kind = 52; 1055 } 1056 break; 1057 case 27: 1058 if (curChar == 85) { 1059 jjCheckNAdd(26); 1060 } 1061 break; 1062 case 28: 1063 if (curChar == 82) { 1064 jjstateSet[jjnewStateCnt++] = 27; 1065 } 1066 break; 1067 case 30: 1068 if (curChar == 114) { 1069 jjstateSet[jjnewStateCnt++] = 29; 1070 } 1071 break; 1072 case 31: 1073 if (curChar == 70) { 1074 jjAddStates(51, 52); 1075 } 1076 break; 1077 case 32: 1078 if (curChar == 83) { 1079 jjCheckNAdd(26); 1080 } 1081 break; 1082 case 33: 1083 if (curChar == 76) { 1084 jjstateSet[jjnewStateCnt++] = 32; 1085 } 1086 break; 1087 case 34: 1088 if (curChar == 65) { 1089 jjstateSet[jjnewStateCnt++] = 33; 1090 } 1091 break; 1092 case 36: 1093 if (curChar == 108) { 1094 jjstateSet[jjnewStateCnt++] = 35; 1095 } 1096 break; 1097 case 37: 1098 if (curChar == 97) { 1099 jjstateSet[jjnewStateCnt++] = 36; 1100 } 1101 break; 1102 case 39: 1103 if ((0x100000001000000L & l) != 0L) { 1104 jjCheckNAdd(40); 1105 } 1106 break; 1107 case 40: 1108 if ((0x7e0000007eL & l) == 0L) { 1109 break; 1110 } 1111 if (kind > 44) { 1112 kind = 44; 1113 } 1114 jjCheckNAddStates(30, 32); 1115 break; 1116 case 46: 1117 if ((0x2000000020L & l) != 0L) { 1118 jjAddStates(57, 58); 1119 } 1120 break; 1121 case 49: 1122 if ((0x1005000010050L & l) != 0L && kind > 50) { 1123 kind = 50; 1124 } 1125 break; 1126 case 51: 1127 if ((0x2000000020L & l) != 0L) { 1128 jjAddStates(59, 60); 1129 } 1130 break; 1131 case 54: 1132 if ((0x60000000000L & l) != 0L && kind > 51) { 1133 kind = 51; 1134 } 1135 break; 1136 case 59: 1137 if ((0x2000000020L & l) != 0L) { 1138 jjAddStates(61, 62); 1139 } 1140 break; 1141 case 63: 1142 if ((0x2000000020L & l) != 0L) { 1143 jjAddStates(63, 64); 1144 } 1145 break; 1146 case 67: 1147 if ((0x2000000020L & l) != 0L) { 1148 jjAddStates(65, 66); 1149 } 1150 break; 1151 case 73: 1152 if ((0x2000000020L & l) != 0L) { 1153 jjAddStates(67, 68); 1154 } 1155 break; 1156 case 77: 1157 if ((0x2000000020L & l) != 0L) { 1158 jjAddStates(69, 70); 1159 } 1160 break; 1161 case 81: 1162 if ((0x2000000020L & l) != 0L) { 1163 jjAddStates(71, 72); 1164 } 1165 break; 1166 default: 1167 break; 1168 } 1169 } while (i != startsAt); 1170 } else { 1171 int i2 = (curChar & 0xff) >> 6; 1172 long l2 = 1L << (curChar & 077); 1173 do { 1174 switch (jjstateSet[--i]) { 1175 case 20: 1176 if ((jjbitVec0[i2] & l2) == 0L) { 1177 break; 1178 } 1179 if (kind > 56) { 1180 kind = 56; 1181 } 1182 jjAddStates(20, 22); 1183 break; 1184 case 23: 1185 if ((jjbitVec0[i2] & l2) == 0L) { 1186 break; 1187 } 1188 if (kind > 56) { 1189 kind = 56; 1190 } 1191 jjAddStates(55, 56); 1192 break; 1193 default: 1194 break; 1195 } 1196 } while (i != startsAt); 1197 } 1198 if (kind != 0x7fffffff) { 1199 jjmatchedKind = kind; 1200 jjmatchedPos = curPos; 1201 kind = 0x7fffffff; 1202 } 1203 ++curPos; 1204 if ((i = jjnewStateCnt) == (startsAt = 84 1205 - (jjnewStateCnt = startsAt))) { 1206 return curPos; 1207 } 1208 try { 1209 curChar = input_stream.readChar(); 1210 } catch (java.io.IOException e) { 1211 return curPos; 1212 } 1213 } 1214 } 1215 1216 private int jjMoveStringLiteralDfa0_3() { 1217 return jjMoveNfa_3(0, 0); 1218 } 1219 1220 private int jjMoveNfa_3(int startState, int curPos) { 1221 int startsAt = 0; 1222 jjnewStateCnt = 10; 1223 int i = 1; 1224 jjstateSet[0] = startState; 1225 int kind = 0x7fffffff; 1226 for (;;) { 1227 if (++jjround == 0x7fffffff) { 1228 ReInitRounds(); 1229 } 1230 if (curChar < 64) { 1231 long l = 1L << curChar; 1232 do { 1233 switch (jjstateSet[--i]) { 1234 case 3: 1235 if ((0x3ff001000000000L & l) == 0L) { 1236 break; 1237 } 1238 if (kind > 54) { 1239 kind = 54; 1240 } 1241 jjCheckNAddTwoStates(3, 5); 1242 break; 1243 case 4: 1244 if (curChar != 58) { 1245 break; 1246 } 1247 if (kind > 54) { 1248 kind = 54; 1249 } 1250 jjCheckNAddTwoStates(3, 5); 1251 break; 1252 case 5: 1253 if (curChar == 58) { 1254 jjstateSet[jjnewStateCnt++] = 4; 1255 } 1256 break; 1257 case 7: 1258 if ((0x3ff001000000000L & l) == 0L) { 1259 break; 1260 } 1261 if (kind > 65) { 1262 kind = 65; 1263 } 1264 jjCheckNAddTwoStates(7, 9); 1265 break; 1266 case 8: 1267 if (curChar != 58) { 1268 break; 1269 } 1270 if (kind > 65) { 1271 kind = 65; 1272 } 1273 jjCheckNAddTwoStates(7, 9); 1274 break; 1275 case 9: 1276 if (curChar == 58) { 1277 jjstateSet[jjnewStateCnt++] = 8; 1278 } 1279 break; 1280 default: 1281 break; 1282 } 1283 } while (i != startsAt); 1284 } else if (curChar < 128) { 1285 long l = 1L << (curChar & 077); 1286 do { 1287 switch (jjstateSet[--i]) { 1288 case 0: 1289 if ((0x7fffffe87fffffeL & l) != 0L) { 1290 if (kind > 54) { 1291 kind = 54; 1292 } 1293 jjCheckNAddStates(73, 78); 1294 } else if (curChar == 125) { 1295 if (kind > 66) { 1296 kind = 66; 1297 } 1298 } 1299 break; 1300 case 1: 1301 if ((0x7fffffe87fffffeL & l) == 0L) { 1302 break; 1303 } 1304 if (kind > 54) { 1305 kind = 54; 1306 } 1307 jjCheckNAddStates(73, 78); 1308 break; 1309 case 2: 1310 if ((0x7fffffe87fffffeL & l) == 0L) { 1311 break; 1312 } 1313 if (kind > 54) { 1314 kind = 54; 1315 } 1316 jjCheckNAddStates(79, 81); 1317 break; 1318 case 3: 1319 if ((0x7fffffe87ffffffL & l) == 0L) { 1320 break; 1321 } 1322 if (kind > 54) { 1323 kind = 54; 1324 } 1325 jjCheckNAddTwoStates(3, 5); 1326 break; 1327 case 6: 1328 if ((0x7fffffe87fffffeL & l) == 0L) { 1329 break; 1330 } 1331 if (kind > 65) { 1332 kind = 65; 1333 } 1334 jjCheckNAddStates(82, 84); 1335 break; 1336 case 7: 1337 if ((0x7fffffe87ffffffL & l) == 0L) { 1338 break; 1339 } 1340 if (kind > 65) { 1341 kind = 65; 1342 } 1343 jjCheckNAddTwoStates(7, 9); 1344 break; 1345 default: 1346 break; 1347 } 1348 } while (i != startsAt); 1349 } else { 1350 do { 1351 switch (jjstateSet[--i]) { 1352 default: 1353 break; 1354 } 1355 } while (i != startsAt); 1356 } 1357 if (kind != 0x7fffffff) { 1358 jjmatchedKind = kind; 1359 jjmatchedPos = curPos; 1360 kind = 0x7fffffff; 1361 } 1362 ++curPos; 1363 if ((i = jjnewStateCnt) == (startsAt = 10 1364 - (jjnewStateCnt = startsAt))) { 1365 return curPos; 1366 } 1367 try { 1368 curChar = input_stream.readChar(); 1369 } catch (java.io.IOException e) { 1370 return curPos; 1371 } 1372 } 1373 } 1374 1375 private int jjMoveStringLiteralDfa0_2() { 1376 switch (curChar) { 1377 case 42: 1378 return jjMoveStringLiteralDfa1_2(0x10L); 1379 default: 1380 return 1; 1381 } 1382 } 1383 1384 private int jjMoveStringLiteralDfa1_2(long active0) { 1385 try { 1386 curChar = input_stream.readChar(); 1387 } catch (java.io.IOException e) { 1388 return 1; 1389 } 1390 switch (curChar) { 1391 case 47: 1392 if ((active0 & 0x10L) != 0L) { 1393 return jjStopAtPos(1, 4); 1394 } 1395 break; 1396 default: 1397 return 2; 1398 } 1399 return 2; 1400 } 1401 1402 private int jjMoveStringLiteralDfa0_6() { 1403 return jjMoveNfa_6(0, 0); 1404 } 1405 1406 private int jjMoveNfa_6(int startState, int curPos) { 1407 int startsAt = 0; 1408 jjnewStateCnt = 2; 1409 int i = 1; 1410 jjstateSet[0] = startState; 1411 int kind = 0x7fffffff; 1412 for (;;) { 1413 if (++jjround == 0x7fffffff) { 1414 ReInitRounds(); 1415 } 1416 if (curChar < 64) { 1417 long l = 1L << curChar; 1418 do { 1419 switch (jjstateSet[--i]) { 1420 case 1: 1421 if ((0x3ff000000000000L & l) == 0L) { 1422 break; 1423 } 1424 kind = 63; 1425 jjstateSet[jjnewStateCnt++] = 1; 1426 break; 1427 default: 1428 break; 1429 } 1430 } while (i != startsAt); 1431 } else if (curChar < 128) { 1432 long l = 1L << (curChar & 077); 1433 do { 1434 switch (jjstateSet[--i]) { 1435 case 0: 1436 if ((0x7fffffe87fffffeL & l) == 0L) { 1437 break; 1438 } 1439 if (kind > 63) { 1440 kind = 63; 1441 } 1442 jjCheckNAddTwoStates(0, 1); 1443 break; 1444 case 1: 1445 if ((0x7fffffe87ffffffL & l) == 0L) { 1446 break; 1447 } 1448 if (kind > 63) { 1449 kind = 63; 1450 } 1451 jjCheckNAdd(1); 1452 break; 1453 default: 1454 break; 1455 } 1456 } while (i != startsAt); 1457 } else { 1458 do { 1459 switch (jjstateSet[--i]) { 1460 default: 1461 break; 1462 } 1463 } while (i != startsAt); 1464 } 1465 if (kind != 0x7fffffff) { 1466 jjmatchedKind = kind; 1467 jjmatchedPos = curPos; 1468 kind = 0x7fffffff; 1469 } 1470 ++curPos; 1471 if ((i = jjnewStateCnt) == (startsAt = 2 1472 - (jjnewStateCnt = startsAt))) { 1473 return curPos; 1474 } 1475 try { 1476 curChar = input_stream.readChar(); 1477 } catch (java.io.IOException e) { 1478 return curPos; 1479 } 1480 } 1481 } 1482 1483 private int jjMoveStringLiteralDfa0_1() { 1484 return jjMoveNfa_1(0, 0); 1485 } 1486 1487 private int jjMoveNfa_1(int startState, int curPos) { 1488 int startsAt = 0; 1489 jjnewStateCnt = 3; 1490 int i = 1; 1491 jjstateSet[0] = startState; 1492 int kind = 0x7fffffff; 1493 for (;;) { 1494 if (++jjround == 0x7fffffff) { 1495 ReInitRounds(); 1496 } 1497 if (curChar < 64) { 1498 long l = 1L << curChar; 1499 do { 1500 switch (jjstateSet[--i]) { 1501 case 0: 1502 if ((0x2400L & l) != 0L) { 1503 if (kind > 3) { 1504 kind = 3; 1505 } 1506 } 1507 if (curChar == 13) { 1508 jjstateSet[jjnewStateCnt++] = 1; 1509 } 1510 break; 1511 case 1: 1512 if (curChar == 10 && kind > 3) { 1513 kind = 3; 1514 } 1515 break; 1516 case 2: 1517 if (curChar == 13) { 1518 jjstateSet[jjnewStateCnt++] = 1; 1519 } 1520 break; 1521 default: 1522 break; 1523 } 1524 } while (i != startsAt); 1525 } else if (curChar < 128) { 1526 do { 1527 switch (jjstateSet[--i]) { 1528 default: 1529 break; 1530 } 1531 } while (i != startsAt); 1532 } else { 1533 do { 1534 switch (jjstateSet[--i]) { 1535 default: 1536 break; 1537 } 1538 } while (i != startsAt); 1539 } 1540 if (kind != 0x7fffffff) { 1541 jjmatchedKind = kind; 1542 jjmatchedPos = curPos; 1543 kind = 0x7fffffff; 1544 } 1545 ++curPos; 1546 if ((i = jjnewStateCnt) == (startsAt = 3 1547 - (jjnewStateCnt = startsAt))) { 1548 return curPos; 1549 } 1550 try { 1551 curChar = input_stream.readChar(); 1552 } catch (java.io.IOException e) { 1553 return curPos; 1554 } 1555 } 1556 } 1557 1558 private int jjMoveStringLiteralDfa0_4() { 1559 return jjMoveNfa_4(0, 0); 1560 } 1561 1562 private int jjMoveNfa_4(int startState, int curPos) { 1563 int startsAt = 0; 1564 jjnewStateCnt = 10; 1565 int i = 1; 1566 jjstateSet[0] = startState; 1567 int kind = 0x7fffffff; 1568 for (;;) { 1569 if (++jjround == 0x7fffffff) { 1570 ReInitRounds(); 1571 } 1572 if (curChar < 64) { 1573 long l = 1L << curChar; 1574 do { 1575 switch (jjstateSet[--i]) { 1576 case 0: 1577 if (curChar == 41) { 1578 kind = 68; 1579 } 1580 break; 1581 case 3: 1582 if ((0x3ff001000000000L & l) == 0L) { 1583 break; 1584 } 1585 if (kind > 54) { 1586 kind = 54; 1587 } 1588 jjCheckNAddTwoStates(3, 5); 1589 break; 1590 case 4: 1591 if (curChar != 58) { 1592 break; 1593 } 1594 if (kind > 54) { 1595 kind = 54; 1596 } 1597 jjCheckNAddTwoStates(3, 5); 1598 break; 1599 case 5: 1600 if (curChar == 58) { 1601 jjstateSet[jjnewStateCnt++] = 4; 1602 } 1603 break; 1604 case 7: 1605 if ((0x3ff001000000000L & l) == 0L) { 1606 break; 1607 } 1608 if (kind > 67) { 1609 kind = 67; 1610 } 1611 jjCheckNAddTwoStates(7, 9); 1612 break; 1613 case 8: 1614 if (curChar != 58) { 1615 break; 1616 } 1617 if (kind > 67) { 1618 kind = 67; 1619 } 1620 jjCheckNAddTwoStates(7, 9); 1621 break; 1622 case 9: 1623 if (curChar == 58) { 1624 jjstateSet[jjnewStateCnt++] = 8; 1625 } 1626 break; 1627 default: 1628 break; 1629 } 1630 } while (i != startsAt); 1631 } else if (curChar < 128) { 1632 long l = 1L << (curChar & 077); 1633 do { 1634 switch (jjstateSet[--i]) { 1635 case 0: 1636 if ((0x7fffffe87fffffeL & l) == 0L) { 1637 break; 1638 } 1639 if (kind > 54) { 1640 kind = 54; 1641 } 1642 jjCheckNAddStates(73, 78); 1643 break; 1644 case 2: 1645 if ((0x7fffffe87fffffeL & l) == 0L) { 1646 break; 1647 } 1648 if (kind > 54) { 1649 kind = 54; 1650 } 1651 jjCheckNAddStates(79, 81); 1652 break; 1653 case 3: 1654 if ((0x7fffffe87ffffffL & l) == 0L) { 1655 break; 1656 } 1657 if (kind > 54) { 1658 kind = 54; 1659 } 1660 jjCheckNAddTwoStates(3, 5); 1661 break; 1662 case 6: 1663 if ((0x7fffffe87fffffeL & l) == 0L) { 1664 break; 1665 } 1666 if (kind > 67) { 1667 kind = 67; 1668 } 1669 jjCheckNAddStates(82, 84); 1670 break; 1671 case 7: 1672 if ((0x7fffffe87ffffffL & l) == 0L) { 1673 break; 1674 } 1675 if (kind > 67) { 1676 kind = 67; 1677 } 1678 jjCheckNAddTwoStates(7, 9); 1679 break; 1680 default: 1681 break; 1682 } 1683 } while (i != startsAt); 1684 } else { 1685 do { 1686 switch (jjstateSet[--i]) { 1687 default: 1688 break; 1689 } 1690 } while (i != startsAt); 1691 } 1692 if (kind != 0x7fffffff) { 1693 jjmatchedKind = kind; 1694 jjmatchedPos = curPos; 1695 kind = 0x7fffffff; 1696 } 1697 ++curPos; 1698 if ((i = jjnewStateCnt) == (startsAt = 10 1699 - (jjnewStateCnt = startsAt))) { 1700 return curPos; 1701 } 1702 try { 1703 curChar = input_stream.readChar(); 1704 } catch (java.io.IOException e) { 1705 return curPos; 1706 } 1707 } 1708 } 1709 1710 static final int[] jjnextStates = { 50, 51, 54, 45, 46, 49, 56, 57, 62, 63, 1711 66, 67, 49, 70, 71, 76, 77, 80, 81, 54, 19, 20, 21, 1, 2, 3, 39, 42, 1712 2, 43, 40, 2, 41, 42, 2, 43, 58, 59, 49, 66, 67, 49, 72, 73, 54, 80, 1713 81, 54, 13, 14, 16, 34, 37, 28, 30, 23, 24, 47, 48, 52, 53, 60, 61, 1714 64, 65, 68, 69, 74, 75, 78, 79, 82, 83, 2, 3, 5, 6, 7, 9, 2, 3, 5, 1715 6, 7, 9, }; 1716 1717 /** Token literal values. */ 1718 public static final String[] jjstrLiteralImages = { "", null, null, null, 1719 null, null, null, null, null, null, "\53", "\55", "\52", "\57", 1720 "\45", "\136", "\50", "\51", "\173", "\175", "\133", "\135", "\54", 1721 "\56", "\72", "\77", "\173\174", "\174\175", "\76", "\74", "\76\75", 1722 "\74\75", "\41\75", "\75\75", "\46\46", "\174\174", "\41", "\176", 1723 "\46", "\174", "\43", "\74\74", "\76\76", "\76\76\76", null, null, 1724 null, null, null, null, null, null, null, 1725 "\146\165\156\143\164\151\157\156", null, null, null, "\75", "\73", 1726 null, "\44", "\44\173", "\44\50", null, null, null, null, null, 1727 null, null, }; 1728 1729 /** Lexer state names. */ 1730 public static final String[] lexStateNames = { "DEFAULT", 1731 "SingleLineCommentMode", "MultiLineCommentMode", 1732 "StringModeIDBrace", "StringModeIDParen", "StringMode", 1733 "StringModeIDNone", }; 1734 1735 /** Lex State array. */ 1736 public static final int[] jjnewLexState = { -1, 1, 2, 0, 0, -1, -1, -1, -1, 1737 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1738 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1739 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1740 6, 3, 4, 5, -1, -1, 5, -1, 5, -1, }; 1741 static final long[] jjtoToken = { 0xff7c1ffffffffc01L, 0x3eL, }; 1742 static final long[] jjtoSkip = { 0x3feL, 0x0L, }; 1743 protected SimpleCharStream input_stream; 1744 private final int[] jjrounds = new int[84]; 1745 private final int[] jjstateSet = new int[168]; 1746 protected char curChar; 1747 1748 /** Constructor. */ 1749 public PtParserTokenManager(SimpleCharStream stream) { 1750 if (SimpleCharStream.staticFlag) { 1751 throw new Error( 1752 "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 1753 } 1754 input_stream = stream; 1755 } 1756 1757 /** Constructor. */ 1758 public PtParserTokenManager(SimpleCharStream stream, int lexState) { 1759 this(stream); 1760 SwitchTo(lexState); 1761 } 1762 1763 /** Reinitialise parser. */ 1764 public void ReInit(SimpleCharStream stream) { 1765 jjmatchedPos = jjnewStateCnt = 0; 1766 curLexState = defaultLexState; 1767 input_stream = stream; 1768 ReInitRounds(); 1769 } 1770 1771 private void ReInitRounds() { 1772 int i; 1773 jjround = 0x80000001; 1774 for (i = 84; i-- > 0;) { 1775 jjrounds[i] = 0x80000000; 1776 } 1777 } 1778 1779 /** Reinitialise parser. */ 1780 public void ReInit(SimpleCharStream stream, int lexState) { 1781 ReInit(stream); 1782 SwitchTo(lexState); 1783 } 1784 1785 /** Switch to specified lex state. */ 1786 public void SwitchTo(int lexState) { 1787 if (lexState >= 7 || lexState < 0) { 1788 throw new TokenMgrError( 1789 "Error: Ignoring invalid lexical state : " + lexState 1790 + ". State unchanged.", 1791 TokenMgrError.INVALID_LEXICAL_STATE); 1792 } else { 1793 curLexState = lexState; 1794 } 1795 } 1796 1797 protected Token jjFillToken() { 1798 final Token t; 1799 final String curTokenImage; 1800 final int beginLine; 1801 final int endLine; 1802 final int beginColumn; 1803 final int endColumn; 1804 String im = jjstrLiteralImages[jjmatchedKind]; 1805 curTokenImage = (im == null) ? input_stream.GetImage() : im; 1806 beginLine = input_stream.getBeginLine(); 1807 beginColumn = input_stream.getBeginColumn(); 1808 endLine = input_stream.getEndLine(); 1809 endColumn = input_stream.getEndColumn(); 1810 t = Token.newToken(jjmatchedKind, curTokenImage); 1811 1812 t.beginLine = beginLine; 1813 t.endLine = endLine; 1814 t.beginColumn = beginColumn; 1815 t.endColumn = endColumn; 1816 1817 return t; 1818 } 1819 1820 int curLexState = 0; 1821 int defaultLexState = 0; 1822 int jjnewStateCnt; 1823 int jjround; 1824 int jjmatchedPos; 1825 int jjmatchedKind; 1826 1827 /** Get the next Token. */ 1828 public Token getNextToken() { 1829 Token matchedToken; 1830 int curPos = 0; 1831 1832 EOFLoop: for (;;) { 1833 try { 1834 curChar = input_stream.BeginToken(); 1835 } catch (java.io.IOException e) { 1836 jjmatchedKind = 0; 1837 matchedToken = jjFillToken(); 1838 return matchedToken; 1839 } 1840 1841 switch (curLexState) { 1842 case 0: 1843 try { 1844 input_stream.backup(0); 1845 while (curChar <= 32 1846 && (0x100002600L & (1L << curChar)) != 0L) { 1847 curChar = input_stream.BeginToken(); 1848 } 1849 } catch (java.io.IOException e1) { 1850 continue EOFLoop; 1851 } 1852 jjmatchedKind = 0x7fffffff; 1853 jjmatchedPos = 0; 1854 curPos = jjMoveStringLiteralDfa0_0(); 1855 if (jjmatchedPos == 0 && jjmatchedKind > 69) { 1856 jjmatchedKind = 69; 1857 } 1858 break; 1859 case 1: 1860 jjmatchedKind = 0x7fffffff; 1861 jjmatchedPos = 0; 1862 curPos = jjMoveStringLiteralDfa0_1(); 1863 if (jjmatchedPos == 0 && jjmatchedKind > 5) { 1864 jjmatchedKind = 5; 1865 } 1866 break; 1867 case 2: 1868 jjmatchedKind = 0x7fffffff; 1869 jjmatchedPos = 0; 1870 curPos = jjMoveStringLiteralDfa0_2(); 1871 if (jjmatchedPos == 0 && jjmatchedKind > 5) { 1872 jjmatchedKind = 5; 1873 } 1874 break; 1875 case 3: 1876 jjmatchedKind = 0x7fffffff; 1877 jjmatchedPos = 0; 1878 curPos = jjMoveStringLiteralDfa0_3(); 1879 break; 1880 case 4: 1881 jjmatchedKind = 0x7fffffff; 1882 jjmatchedPos = 0; 1883 curPos = jjMoveStringLiteralDfa0_4(); 1884 break; 1885 case 5: 1886 jjmatchedKind = 0x7fffffff; 1887 jjmatchedPos = 0; 1888 curPos = jjMoveStringLiteralDfa0_5(); 1889 break; 1890 case 6: 1891 jjmatchedKind = 0x7fffffff; 1892 jjmatchedPos = 0; 1893 curPos = jjMoveStringLiteralDfa0_6(); 1894 break; 1895 } 1896 if (jjmatchedKind != 0x7fffffff) { 1897 if (jjmatchedPos + 1 < curPos) { 1898 input_stream.backup(curPos - jjmatchedPos - 1); 1899 } 1900 if ((jjtoToken[jjmatchedKind >> 6] 1901 & (1L << (jjmatchedKind & 077))) != 0L) { 1902 matchedToken = jjFillToken(); 1903 if (jjnewLexState[jjmatchedKind] != -1) { 1904 curLexState = jjnewLexState[jjmatchedKind]; 1905 } 1906 return matchedToken; 1907 } else { 1908 if (jjnewLexState[jjmatchedKind] != -1) { 1909 curLexState = jjnewLexState[jjmatchedKind]; 1910 } 1911 continue EOFLoop; 1912 } 1913 } 1914 int error_line = input_stream.getEndLine(); 1915 int error_column = input_stream.getEndColumn(); 1916 String error_after = null; 1917 boolean EOFSeen = false; 1918 try { 1919 input_stream.readChar(); 1920 input_stream.backup(1); 1921 } catch (java.io.IOException e1) { 1922 EOFSeen = true; 1923 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 1924 if (curChar == '\n' || curChar == '\r') { 1925 error_line++; 1926 error_column = 0; 1927 } else { 1928 error_column++; 1929 } 1930 } 1931 if (!EOFSeen) { 1932 input_stream.backup(1); 1933 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 1934 } 1935 throw new TokenMgrError(EOFSeen, curLexState, error_line, 1936 error_column, error_after, curChar, 1937 TokenMgrError.LEXICAL_ERROR); 1938 } 1939 } 1940 1941 private void jjCheckNAdd(int state) { 1942 if (jjrounds[state] != jjround) { 1943 jjstateSet[jjnewStateCnt++] = state; 1944 jjrounds[state] = jjround; 1945 } 1946 } 1947 1948 private void jjAddStates(int start, int end) { 1949 do { 1950 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 1951 } while (start++ != end); 1952 } 1953 1954 private void jjCheckNAddTwoStates(int state1, int state2) { 1955 jjCheckNAdd(state1); 1956 jjCheckNAdd(state2); 1957 } 1958 1959 private void jjCheckNAddStates(int start, int end) { 1960 do { 1961 jjCheckNAdd(jjnextStates[start]); 1962 } while (start++ != end); 1963 } 1964 1965}