001 /* Generated By:JavaCC: Do not edit this line. ParserTokenManager.java */ 002 package edu.upenn.gloDB.parser; 003 import edu.upenn.gloDB.*; 004 import java.io.StringReader; 005 import java.util.HashMap; 006 import java.util.HashSet; 007 import java.util.ArrayList; 008 import java.util.Iterator; 009 010 public class ParserTokenManager implements ParserConstants 011 { 012 public java.io.PrintStream debugStream = System.out; 013 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } 014 private final int jjStopStringLiteralDfa_0(int pos, long active0) 015 { 016 switch (pos) 017 { 018 case 0: 019 if ((active0 & 0x100000000L) != 0L) 020 return 2; 021 if ((active0 & 0x24000000L) != 0L) 022 { 023 jjmatchedKind = 43; 024 return 22; 025 } 026 if ((active0 & 0x3c011000004L) != 0L) 027 { 028 jjmatchedKind = 43; 029 return 99; 030 } 031 if ((active0 & 0x8L) != 0L) 032 { 033 jjmatchedKind = 43; 034 return 30; 035 } 036 if ((active0 & 0x1000L) != 0L) 037 return 100; 038 if ((active0 & 0x8000000L) != 0L) 039 { 040 jjmatchedKind = 43; 041 return 19; 042 } 043 if ((active0 & 0x2000000L) != 0L) 044 { 045 jjmatchedKind = 43; 046 return 75; 047 } 048 return -1; 049 case 1: 050 if ((active0 & 0x3c03700000cL) != 0L) 051 { 052 jjmatchedKind = 43; 053 jjmatchedPos = 1; 054 return 99; 055 } 056 if ((active0 & 0x8000000L) != 0L) 057 return 99; 058 return -1; 059 case 2: 060 if ((active0 & 0x3000000L) != 0L) 061 return 99; 062 if ((active0 & 0x3c03400000cL) != 0L) 063 { 064 if (jjmatchedPos != 2) 065 { 066 jjmatchedKind = 43; 067 jjmatchedPos = 2; 068 } 069 return 99; 070 } 071 return -1; 072 case 3: 073 if ((active0 & 0x3c030000008L) != 0L) 074 { 075 jjmatchedKind = 43; 076 jjmatchedPos = 3; 077 return 99; 078 } 079 if ((active0 & 0x4000004L) != 0L) 080 return 99; 081 return -1; 082 case 4: 083 if ((active0 & 0x34020000008L) != 0L) 084 { 085 jjmatchedKind = 43; 086 jjmatchedPos = 4; 087 return 99; 088 } 089 if ((active0 & 0x8010000000L) != 0L) 090 return 99; 091 return -1; 092 case 5: 093 if ((active0 & 0x4020000000L) != 0L) 094 return 99; 095 if ((active0 & 0x30000000008L) != 0L) 096 { 097 jjmatchedKind = 43; 098 jjmatchedPos = 5; 099 return 99; 100 } 101 return -1; 102 case 6: 103 if ((active0 & 0x30000000008L) != 0L) 104 { 105 jjmatchedKind = 43; 106 jjmatchedPos = 6; 107 return 99; 108 } 109 return -1; 110 case 7: 111 if ((active0 & 0x20000000008L) != 0L) 112 { 113 jjmatchedKind = 43; 114 jjmatchedPos = 7; 115 return 99; 116 } 117 if ((active0 & 0x10000000000L) != 0L) 118 return 99; 119 return -1; 120 case 8: 121 if ((active0 & 0x8L) != 0L) 122 { 123 if (jjmatchedPos < 7) 124 { 125 jjmatchedKind = 43; 126 jjmatchedPos = 7; 127 } 128 return 101; 129 } 130 if ((active0 & 0x20000000000L) != 0L) 131 return 99; 132 return -1; 133 case 9: 134 if ((active0 & 0x8L) != 0L) 135 { 136 if (jjmatchedPos < 7) 137 { 138 jjmatchedKind = 43; 139 jjmatchedPos = 7; 140 } 141 return -1; 142 } 143 return -1; 144 default : 145 return -1; 146 } 147 } 148 private final int jjStartNfa_0(int pos, long active0) 149 { 150 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 151 } 152 private final int jjStopAtPos(int pos, int kind) 153 { 154 jjmatchedKind = kind; 155 jjmatchedPos = pos; 156 return pos + 1; 157 } 158 private final int jjStartNfaWithStates_0(int pos, int kind, int state) 159 { 160 jjmatchedKind = kind; 161 jjmatchedPos = pos; 162 try { curChar = input_stream.readChar(); } 163 catch(java.io.IOException e) { return pos + 1; } 164 return jjMoveNfa_0(state, pos + 1); 165 } 166 private final int jjMoveStringLiteralDfa0_0() 167 { 168 switch(curChar) 169 { 170 case 10: 171 return jjStopAtPos(0, 37); 172 case 33: 173 return jjStopAtPos(0, 33); 174 case 38: 175 return jjMoveStringLiteralDfa1_0(0x40000000L); 176 case 40: 177 return jjStopAtPos(0, 19); 178 case 41: 179 return jjStopAtPos(0, 20); 180 case 42: 181 return jjStopAtPos(0, 36); 182 case 43: 183 return jjStopAtPos(0, 35); 184 case 44: 185 return jjStopAtPos(0, 9); 186 case 45: 187 return jjStartNfaWithStates_0(0, 32, 2); 188 case 59: 189 return jjStopAtPos(0, 47); 190 case 60: 191 return jjStartNfaWithStates_0(0, 12, 100); 192 case 61: 193 return jjStopAtPos(0, 8); 194 case 62: 195 return jjStopAtPos(0, 14); 196 case 63: 197 return jjStopAtPos(0, 34); 198 case 91: 199 return jjStopAtPos(0, 21); 200 case 93: 201 return jjStopAtPos(0, 22); 202 case 65: 203 case 97: 204 return jjMoveStringLiteralDfa1_0(0x2000000L); 205 case 70: 206 case 102: 207 return jjMoveStringLiteralDfa1_0(0x8L); 208 case 77: 209 case 109: 210 return jjMoveStringLiteralDfa1_0(0x10000000L); 211 case 79: 212 case 111: 213 return jjMoveStringLiteralDfa1_0(0x8000000L); 214 case 80: 215 case 112: 216 return jjMoveStringLiteralDfa1_0(0x20001000000L); 217 case 82: 218 case 114: 219 return jjMoveStringLiteralDfa1_0(0x10000000000L); 220 case 83: 221 case 115: 222 return jjMoveStringLiteralDfa1_0(0x24000000L); 223 case 84: 224 case 116: 225 return jjMoveStringLiteralDfa1_0(0x8000000004L); 226 case 87: 227 case 119: 228 return jjMoveStringLiteralDfa1_0(0x4000000000L); 229 case 123: 230 return jjStopAtPos(0, 17); 231 case 124: 232 return jjMoveStringLiteralDfa1_0(0x80000000L); 233 case 125: 234 return jjStopAtPos(0, 18); 235 case 126: 236 return jjStopAtPos(0, 23); 237 default : 238 return jjMoveNfa_0(1, 0); 239 } 240 } 241 private final int jjMoveStringLiteralDfa1_0(long active0) 242 { 243 try { curChar = input_stream.readChar(); } 244 catch(java.io.IOException e) { 245 jjStopStringLiteralDfa_0(0, active0); 246 return 1; 247 } 248 switch(curChar) 249 { 250 case 38: 251 if ((active0 & 0x40000000L) != 0L) 252 return jjStopAtPos(1, 30); 253 break; 254 case 65: 255 case 97: 256 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L); 257 case 69: 258 case 101: 259 return jjMoveStringLiteralDfa2_0(active0, 0x10000000000L); 260 case 72: 261 case 104: 262 return jjMoveStringLiteralDfa2_0(active0, 0x4L); 263 case 73: 264 case 105: 265 return jjMoveStringLiteralDfa2_0(active0, 0xc010000000L); 266 case 77: 267 case 109: 268 return jjMoveStringLiteralDfa2_0(active0, 0x20000000L); 269 case 78: 270 case 110: 271 return jjMoveStringLiteralDfa2_0(active0, 0x2000000L); 272 case 79: 273 case 111: 274 return jjMoveStringLiteralDfa2_0(active0, 0x20001000008L); 275 case 82: 276 case 114: 277 if ((active0 & 0x8000000L) != 0L) 278 return jjStartNfaWithStates_0(1, 27, 99); 279 break; 280 case 124: 281 if ((active0 & 0x80000000L) != 0L) 282 return jjStopAtPos(1, 31); 283 break; 284 default : 285 break; 286 } 287 return jjStartNfa_0(0, active0); 288 } 289 private final int jjMoveStringLiteralDfa2_0(long old0, long active0) 290 { 291 if (((active0 &= old0)) == 0L) 292 return jjStartNfa_0(0, old0); 293 try { curChar = input_stream.readChar(); } 294 catch(java.io.IOException e) { 295 jjStopStringLiteralDfa_0(1, active0); 296 return 2; 297 } 298 switch(curChar) 299 { 300 case 68: 301 case 100: 302 if ((active0 & 0x2000000L) != 0L) 303 return jjStartNfaWithStates_0(2, 25, 99); 304 break; 305 case 69: 306 case 101: 307 return jjMoveStringLiteralDfa3_0(active0, 0x4L); 308 case 73: 309 case 105: 310 return jjMoveStringLiteralDfa3_0(active0, 0x20000000L); 311 case 76: 312 case 108: 313 return jjMoveStringLiteralDfa3_0(active0, 0x8L); 314 case 77: 315 case 109: 316 return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L); 317 case 78: 318 case 110: 319 return jjMoveStringLiteralDfa3_0(active0, 0x14000000L); 320 case 80: 321 case 112: 322 return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L); 323 case 83: 324 case 115: 325 if ((active0 & 0x1000000L) != 0L) 326 { 327 jjmatchedKind = 24; 328 jjmatchedPos = 2; 329 } 330 return jjMoveStringLiteralDfa3_0(active0, 0x20000000000L); 331 case 84: 332 case 116: 333 return jjMoveStringLiteralDfa3_0(active0, 0x4000000000L); 334 default : 335 break; 336 } 337 return jjStartNfa_0(1, active0); 338 } 339 private final int jjMoveStringLiteralDfa3_0(long old0, long active0) 340 { 341 if (((active0 &= old0)) == 0L) 342 return jjStartNfa_0(1, old0); 343 try { curChar = input_stream.readChar(); } 344 catch(java.io.IOException e) { 345 jjStopStringLiteralDfa_0(2, active0); 346 return 3; 347 } 348 switch(curChar) 349 { 350 case 68: 351 case 100: 352 if ((active0 & 0x4000000L) != 0L) 353 return jjStartNfaWithStates_0(3, 26, 99); 354 break; 355 case 69: 356 case 101: 357 return jjMoveStringLiteralDfa4_0(active0, 0x18000000000L); 358 case 72: 359 case 104: 360 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000L); 361 case 73: 362 case 105: 363 return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L); 364 case 76: 365 case 108: 366 return jjMoveStringLiteralDfa4_0(active0, 0x8L); 367 case 78: 368 case 110: 369 if ((active0 & 0x4L) != 0L) 370 return jjStartNfaWithStates_0(3, 2, 99); 371 return jjMoveStringLiteralDfa4_0(active0, 0x20000000L); 372 case 85: 373 case 117: 374 return jjMoveStringLiteralDfa4_0(active0, 0x10000000L); 375 default : 376 break; 377 } 378 return jjStartNfa_0(2, active0); 379 } 380 private final int jjMoveStringLiteralDfa4_0(long old0, long active0) 381 { 382 if (((active0 &= old0)) == 0L) 383 return jjStartNfa_0(2, old0); 384 try { curChar = input_stream.readChar(); } 385 catch(java.io.IOException e) { 386 jjStopStringLiteralDfa_0(3, active0); 387 return 4; 388 } 389 switch(curChar) 390 { 391 case 65: 392 case 97: 393 return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L); 394 case 73: 395 case 105: 396 return jjMoveStringLiteralDfa5_0(active0, 0x4000000000L); 397 case 79: 398 case 111: 399 return jjMoveStringLiteralDfa5_0(active0, 0x8L); 400 case 83: 401 case 115: 402 if ((active0 & 0x10000000L) != 0L) 403 return jjStartNfaWithStates_0(4, 28, 99); 404 else if ((active0 & 0x8000000000L) != 0L) 405 return jjStartNfaWithStates_0(4, 39, 99); 406 break; 407 case 84: 408 case 116: 409 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L); 410 case 85: 411 case 117: 412 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L); 413 default : 414 break; 415 } 416 return jjStartNfa_0(3, active0); 417 } 418 private final int jjMoveStringLiteralDfa5_0(long old0, long active0) 419 { 420 if (((active0 &= old0)) == 0L) 421 return jjStartNfa_0(3, old0); 422 try { curChar = input_stream.readChar(); } 423 catch(java.io.IOException e) { 424 jjStopStringLiteralDfa_0(4, active0); 425 return 5; 426 } 427 switch(curChar) 428 { 429 case 73: 430 case 105: 431 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L); 432 case 78: 433 case 110: 434 if ((active0 & 0x4000000000L) != 0L) 435 return jjStartNfaWithStates_0(5, 38, 99); 436 break; 437 case 83: 438 case 115: 439 if ((active0 & 0x20000000L) != 0L) 440 return jjStartNfaWithStates_0(5, 29, 99); 441 break; 442 case 84: 443 case 116: 444 return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L); 445 case 87: 446 case 119: 447 return jjMoveStringLiteralDfa6_0(active0, 0x8L); 448 default : 449 break; 450 } 451 return jjStartNfa_0(4, active0); 452 } 453 private final int jjMoveStringLiteralDfa6_0(long old0, long active0) 454 { 455 if (((active0 &= old0)) == 0L) 456 return jjStartNfa_0(4, old0); 457 try { curChar = input_stream.readChar(); } 458 catch(java.io.IOException e) { 459 jjStopStringLiteralDfa_0(5, active0); 460 return 6; 461 } 462 switch(curChar) 463 { 464 case 69: 465 case 101: 466 return jjMoveStringLiteralDfa7_0(active0, 0x10000000008L); 467 case 79: 468 case 111: 469 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000L); 470 default : 471 break; 472 } 473 return jjStartNfa_0(5, active0); 474 } 475 private final int jjMoveStringLiteralDfa7_0(long old0, long active0) 476 { 477 if (((active0 &= old0)) == 0L) 478 return jjStartNfa_0(5, old0); 479 try { curChar = input_stream.readChar(); } 480 catch(java.io.IOException e) { 481 jjStopStringLiteralDfa_0(6, active0); 482 return 7; 483 } 484 switch(curChar) 485 { 486 case 68: 487 case 100: 488 if ((active0 & 0x10000000000L) != 0L) 489 return jjStartNfaWithStates_0(7, 40, 99); 490 return jjMoveStringLiteralDfa8_0(active0, 0x8L); 491 case 78: 492 case 110: 493 return jjMoveStringLiteralDfa8_0(active0, 0x20000000000L); 494 default : 495 break; 496 } 497 return jjStartNfa_0(6, active0); 498 } 499 private final int jjMoveStringLiteralDfa8_0(long old0, long active0) 500 { 501 if (((active0 &= old0)) == 0L) 502 return jjStartNfa_0(6, old0); 503 try { curChar = input_stream.readChar(); } 504 catch(java.io.IOException e) { 505 jjStopStringLiteralDfa_0(7, active0); 506 return 8; 507 } 508 switch(curChar) 509 { 510 case 32: 511 return jjMoveStringLiteralDfa9_0(active0, 0x8L); 512 case 83: 513 case 115: 514 if ((active0 & 0x20000000000L) != 0L) 515 return jjStartNfaWithStates_0(8, 41, 99); 516 break; 517 default : 518 break; 519 } 520 return jjStartNfa_0(7, active0); 521 } 522 private final int jjMoveStringLiteralDfa9_0(long old0, long active0) 523 { 524 if (((active0 &= old0)) == 0L) 525 return jjStartNfa_0(7, old0); 526 try { curChar = input_stream.readChar(); } 527 catch(java.io.IOException e) { 528 jjStopStringLiteralDfa_0(8, active0); 529 return 9; 530 } 531 switch(curChar) 532 { 533 case 66: 534 case 98: 535 return jjMoveStringLiteralDfa10_0(active0, 0x8L); 536 default : 537 break; 538 } 539 return jjStartNfa_0(8, active0); 540 } 541 private final int jjMoveStringLiteralDfa10_0(long old0, long active0) 542 { 543 if (((active0 &= old0)) == 0L) 544 return jjStartNfa_0(8, old0); 545 try { curChar = input_stream.readChar(); } 546 catch(java.io.IOException e) { 547 jjStopStringLiteralDfa_0(9, active0); 548 return 10; 549 } 550 switch(curChar) 551 { 552 case 89: 553 case 121: 554 if ((active0 & 0x8L) != 0L) 555 return jjStopAtPos(10, 3); 556 break; 557 default : 558 break; 559 } 560 return jjStartNfa_0(9, active0); 561 } 562 private final void jjCheckNAdd(int state) 563 { 564 if (jjrounds[state] != jjround) 565 { 566 jjstateSet[jjnewStateCnt++] = state; 567 jjrounds[state] = jjround; 568 } 569 } 570 private final void jjAddStates(int start, int end) 571 { 572 do { 573 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 574 } while (start++ != end); 575 } 576 private final void jjCheckNAddTwoStates(int state1, int state2) 577 { 578 jjCheckNAdd(state1); 579 jjCheckNAdd(state2); 580 } 581 private final void jjCheckNAddStates(int start, int end) 582 { 583 do { 584 jjCheckNAdd(jjnextStates[start]); 585 } while (start++ != end); 586 } 587 private final void jjCheckNAddStates(int start) 588 { 589 jjCheckNAdd(jjnextStates[start]); 590 jjCheckNAdd(jjnextStates[start + 1]); 591 } 592 private final int jjMoveNfa_0(int startState, int curPos) 593 { 594 int[] nextStates; 595 int startsAt = 0; 596 jjnewStateCnt = 99; 597 int i = 1; 598 jjstateSet[0] = startState; 599 int j, kind = 0x7fffffff; 600 for (;;) 601 { 602 if (++jjround == 0x7fffffff) 603 ReInitRounds(); 604 if (curChar < 64) 605 { 606 long l = 1L << curChar; 607 MatchLoop: do 608 { 609 switch(jjstateSet[--i]) 610 { 611 case 30: 612 if ((0x3ff200000000000L & l) != 0L) 613 jjCheckNAddStates(0, 2); 614 else if (curChar == 61) 615 { 616 if (kind > 44) 617 kind = 44; 618 } 619 else if (curChar == 32) 620 jjCheckNAddTwoStates(97, 98); 621 if ((0x3ff200000000000L & l) != 0L) 622 { 623 if (kind > 43) 624 kind = 43; 625 jjCheckNAdd(95); 626 } 627 break; 628 case 101: 629 if (curChar == 61) 630 { 631 if (kind > 44) 632 kind = 44; 633 } 634 else if (curChar == 32) 635 jjCheckNAddTwoStates(97, 98); 636 break; 637 case 100: 638 if (curChar == 59) 639 { 640 if (kind > 13) 641 kind = 13; 642 } 643 else if (curChar == 32) 644 jjCheckNAddTwoStates(4, 5); 645 break; 646 case 75: 647 if ((0x3ff200000000000L & l) != 0L) 648 jjCheckNAddStates(0, 2); 649 else if (curChar == 32) 650 jjstateSet[jjnewStateCnt++] = 92; 651 else if (curChar == 61) 652 { 653 if (kind > 44) 654 kind = 44; 655 } 656 if ((0x3ff200000000000L & l) != 0L) 657 { 658 if (kind > 43) 659 kind = 43; 660 jjCheckNAdd(95); 661 } 662 else if (curChar == 32) 663 jjCheckNAddTwoStates(97, 98); 664 if (curChar == 32) 665 jjstateSet[jjnewStateCnt++] = 74; 666 break; 667 case 19: 668 if ((0x3ff200000000000L & l) != 0L) 669 jjCheckNAddStates(0, 2); 670 else if (curChar == 61) 671 { 672 if (kind > 44) 673 kind = 44; 674 } 675 else if (curChar == 32) 676 jjCheckNAddTwoStates(97, 98); 677 if ((0x3ff200000000000L & l) != 0L) 678 { 679 if (kind > 43) 680 kind = 43; 681 jjCheckNAdd(95); 682 } 683 break; 684 case 22: 685 if ((0x3ff200000000000L & l) != 0L) 686 jjCheckNAddStates(0, 2); 687 else if (curChar == 58) 688 { 689 if (kind > 46) 690 kind = 46; 691 jjCheckNAdd(23); 692 } 693 else if (curChar == 61) 694 { 695 if (kind > 44) 696 kind = 44; 697 } 698 else if (curChar == 32) 699 jjCheckNAddTwoStates(97, 98); 700 if ((0x3ff200000000000L & l) != 0L) 701 { 702 if (kind > 43) 703 kind = 43; 704 jjCheckNAdd(95); 705 } 706 break; 707 case 99: 708 if ((0x3ff200000000000L & l) != 0L) 709 jjCheckNAddStates(0, 2); 710 else if (curChar == 61) 711 { 712 if (kind > 44) 713 kind = 44; 714 } 715 else if (curChar == 32) 716 jjCheckNAddTwoStates(97, 98); 717 if ((0x3ff200000000000L & l) != 0L) 718 { 719 if (kind > 43) 720 kind = 43; 721 jjCheckNAdd(95); 722 } 723 break; 724 case 1: 725 if ((0x3ff000000000000L & l) != 0L) 726 { 727 if (kind > 10) 728 kind = 10; 729 jjCheckNAdd(0); 730 } 731 else if (curChar == 60) 732 jjCheckNAddTwoStates(4, 5); 733 else if (curChar == 45) 734 jjCheckNAdd(2); 735 break; 736 case 0: 737 if ((0x3ff000000000000L & l) == 0L) 738 break; 739 if (kind > 10) 740 kind = 10; 741 jjCheckNAdd(0); 742 break; 743 case 2: 744 if ((0x3ff000000000000L & l) == 0L) 745 break; 746 if (kind > 11) 747 kind = 11; 748 jjCheckNAdd(2); 749 break; 750 case 3: 751 if (curChar == 60) 752 jjCheckNAddTwoStates(4, 5); 753 break; 754 case 4: 755 if (curChar == 32) 756 jjCheckNAddTwoStates(4, 5); 757 break; 758 case 5: 759 if (curChar == 59) 760 kind = 13; 761 break; 762 case 10: 763 if (curChar != 32) 764 break; 765 if (kind > 46) 766 kind = 46; 767 jjstateSet[jjnewStateCnt++] = 10; 768 break; 769 case 18: 770 if (curChar == 32) 771 jjstateSet[jjnewStateCnt++] = 17; 772 break; 773 case 23: 774 if (curChar != 32) 775 break; 776 if (kind > 46) 777 kind = 46; 778 jjCheckNAdd(23); 779 break; 780 case 25: 781 if (curChar != 32) 782 break; 783 if (kind > 46) 784 kind = 46; 785 jjstateSet[jjnewStateCnt++] = 25; 786 break; 787 case 39: 788 if (curChar == 32) 789 jjstateSet[jjnewStateCnt++] = 38; 790 break; 791 case 48: 792 if (curChar == 32) 793 jjstateSet[jjnewStateCnt++] = 47; 794 break; 795 case 60: 796 if (curChar == 32) 797 jjstateSet[jjnewStateCnt++] = 59; 798 break; 799 case 64: 800 if (curChar == 32) 801 jjstateSet[jjnewStateCnt++] = 63; 802 break; 803 case 67: 804 if (curChar == 32) 805 jjstateSet[jjnewStateCnt++] = 66; 806 break; 807 case 77: 808 if (curChar != 32) 809 break; 810 if (kind > 45) 811 kind = 45; 812 jjstateSet[jjnewStateCnt++] = 77; 813 break; 814 case 82: 815 if (curChar == 32) 816 jjstateSet[jjnewStateCnt++] = 81; 817 break; 818 case 85: 819 if (curChar == 32) 820 jjstateSet[jjnewStateCnt++] = 84; 821 break; 822 case 93: 823 if (curChar == 32) 824 jjstateSet[jjnewStateCnt++] = 92; 825 break; 826 case 95: 827 if ((0x3ff200000000000L & l) == 0L) 828 break; 829 if (kind > 43) 830 kind = 43; 831 jjCheckNAdd(95); 832 break; 833 case 96: 834 if ((0x3ff200000000000L & l) != 0L) 835 jjCheckNAddStates(0, 2); 836 break; 837 case 97: 838 if (curChar == 32) 839 jjCheckNAddTwoStates(97, 98); 840 break; 841 case 98: 842 if (curChar == 61) 843 kind = 44; 844 break; 845 default : break; 846 } 847 } while(i != startsAt); 848 } 849 else if (curChar < 128) 850 { 851 long l = 1L << (curChar & 077); 852 MatchLoop: do 853 { 854 switch(jjstateSet[--i]) 855 { 856 case 30: 857 if ((0x7fffffe87fffffeL & l) != 0L) 858 jjCheckNAddStates(0, 2); 859 if ((0x7fffffe87fffffeL & l) != 0L) 860 { 861 if (kind > 43) 862 kind = 43; 863 jjCheckNAdd(95); 864 } 865 if ((0x4000000040000L & l) != 0L) 866 jjstateSet[jjnewStateCnt++] = 41; 867 if ((0x4000000040000L & l) != 0L) 868 jjstateSet[jjnewStateCnt++] = 29; 869 break; 870 case 75: 871 if ((0x7fffffe87fffffeL & l) != 0L) 872 jjCheckNAddStates(0, 2); 873 if ((0x7fffffe87fffffeL & l) != 0L) 874 { 875 if (kind > 43) 876 kind = 43; 877 jjCheckNAdd(95); 878 } 879 break; 880 case 19: 881 if ((0x7fffffe87fffffeL & l) != 0L) 882 jjCheckNAddStates(0, 2); 883 if ((0x7fffffe87fffffeL & l) != 0L) 884 { 885 if (kind > 43) 886 kind = 43; 887 jjCheckNAdd(95); 888 } 889 if ((0x400000004000L & l) != 0L) 890 jjstateSet[jjnewStateCnt++] = 18; 891 break; 892 case 22: 893 if ((0x7fffffe87fffffeL & l) != 0L) 894 jjCheckNAddStates(0, 2); 895 if ((0x7fffffe87fffffeL & l) != 0L) 896 { 897 if (kind > 43) 898 kind = 43; 899 jjCheckNAdd(95); 900 } 901 if ((0x2000000020L & l) != 0L) 902 jjstateSet[jjnewStateCnt++] = 24; 903 break; 904 case 99: 905 if ((0x7fffffe87fffffeL & l) != 0L) 906 jjCheckNAddStates(0, 2); 907 if ((0x7fffffe87fffffeL & l) != 0L) 908 { 909 if (kind > 43) 910 kind = 43; 911 jjCheckNAdd(95); 912 } 913 break; 914 case 1: 915 if ((0x7fffffe87fffffeL & l) != 0L) 916 { 917 if (kind > 43) 918 kind = 43; 919 jjCheckNAddStates(3, 6); 920 } 921 if ((0x200000002L & l) != 0L) 922 jjAddStates(7, 8); 923 else if ((0x100000001000L & l) != 0L) 924 jjAddStates(9, 10); 925 else if ((0x4000000040L & l) != 0L) 926 jjAddStates(11, 12); 927 else if ((0x8000000080000L & l) != 0L) 928 jjAddStates(13, 14); 929 else if ((0x800000008000L & l) != 0L) 930 jjstateSet[jjnewStateCnt++] = 19; 931 else if (curChar == 95) 932 jjstateSet[jjnewStateCnt++] = 7; 933 break; 934 case 6: 935 if ((0x10000000100000L & l) != 0L && kind > 42) 936 kind = 42; 937 break; 938 case 7: 939 if (curChar == 95) 940 jjstateSet[jjnewStateCnt++] = 6; 941 break; 942 case 8: 943 if (curChar == 95) 944 jjstateSet[jjnewStateCnt++] = 7; 945 break; 946 case 9: 947 if ((0x2000000020L & l) != 0L) 948 jjstateSet[jjnewStateCnt++] = 10; 949 break; 950 case 11: 951 if ((0x800000008L & l) != 0L) 952 jjstateSet[jjnewStateCnt++] = 9; 953 break; 954 case 12: 955 if ((0x400000004000L & l) != 0L) 956 jjstateSet[jjnewStateCnt++] = 11; 957 break; 958 case 13: 959 if ((0x2000000020L & l) != 0L) 960 jjstateSet[jjnewStateCnt++] = 12; 961 break; 962 case 14: 963 if ((0x20000000200000L & l) != 0L) 964 jjstateSet[jjnewStateCnt++] = 13; 965 break; 966 case 15: 967 if ((0x2000000020000L & l) != 0L) 968 jjstateSet[jjnewStateCnt++] = 14; 969 break; 970 case 16: 971 if ((0x2000000020L & l) != 0L) 972 jjstateSet[jjnewStateCnt++] = 15; 973 break; 974 case 17: 975 if ((0x8000000080000L & l) != 0L) 976 jjstateSet[jjnewStateCnt++] = 16; 977 break; 978 case 20: 979 if ((0x800000008000L & l) != 0L) 980 jjstateSet[jjnewStateCnt++] = 19; 981 break; 982 case 21: 983 if ((0x8000000080000L & l) != 0L) 984 jjAddStates(13, 14); 985 break; 986 case 24: 987 if ((0x2000000020000L & l) != 0L) 988 jjstateSet[jjnewStateCnt++] = 25; 989 break; 990 case 26: 991 if ((0x2000000020L & l) != 0L) 992 jjstateSet[jjnewStateCnt++] = 24; 993 break; 994 case 27: 995 if ((0x4000000040L & l) != 0L) 996 jjAddStates(11, 12); 997 break; 998 case 28: 999 if ((0x200000002000L & l) != 0L && kind > 16) 1000 kind = 16; 1001 break; 1002 case 29: 1003 if ((0x800000008000L & l) != 0L) 1004 jjstateSet[jjnewStateCnt++] = 28; 1005 break; 1006 case 31: 1007 if ((0x400000004000L & l) != 0L && kind > 16) 1008 kind = 16; 1009 break; 1010 case 32: 1011 if ((0x800000008000L & l) != 0L) 1012 jjstateSet[jjnewStateCnt++] = 31; 1013 break; 1014 case 33: 1015 if ((0x20000000200L & l) != 0L) 1016 jjstateSet[jjnewStateCnt++] = 32; 1017 break; 1018 case 34: 1019 if ((0x10000000100000L & l) != 0L) 1020 jjstateSet[jjnewStateCnt++] = 33; 1021 break; 1022 case 35: 1023 if ((0x20000000200L & l) != 0L) 1024 jjstateSet[jjnewStateCnt++] = 34; 1025 break; 1026 case 36: 1027 if ((0x8000000080000L & l) != 0L) 1028 jjstateSet[jjnewStateCnt++] = 35; 1029 break; 1030 case 37: 1031 if ((0x800000008000L & l) != 0L) 1032 jjstateSet[jjnewStateCnt++] = 36; 1033 break; 1034 case 38: 1035 if ((0x1000000010000L & l) != 0L) 1036 jjstateSet[jjnewStateCnt++] = 37; 1037 break; 1038 case 40: 1039 if ((0x200000002000L & l) != 0L) 1040 jjstateSet[jjnewStateCnt++] = 39; 1041 break; 1042 case 41: 1043 if ((0x800000008000L & l) != 0L) 1044 jjstateSet[jjnewStateCnt++] = 40; 1045 break; 1046 case 42: 1047 if ((0x4000000040000L & l) != 0L) 1048 jjstateSet[jjnewStateCnt++] = 41; 1049 break; 1050 case 43: 1051 if ((0x100000001000L & l) != 0L) 1052 jjAddStates(9, 10); 1053 break; 1054 case 44: 1055 if ((0x400000004000L & l) != 0L && kind > 15) 1056 kind = 15; 1057 break; 1058 case 45: 1059 if ((0x2000000020L & l) != 0L) 1060 jjstateSet[jjnewStateCnt++] = 44; 1061 break; 1062 case 46: 1063 if ((0x4000000040L & l) != 0L && kind > 15) 1064 kind = 15; 1065 break; 1066 case 47: 1067 if ((0x800000008000L & l) != 0L) 1068 jjstateSet[jjnewStateCnt++] = 46; 1069 break; 1070 case 49: 1071 if ((0x10000000100L & l) != 0L) 1072 jjstateSet[jjnewStateCnt++] = 48; 1073 break; 1074 case 50: 1075 if ((0x10000000100000L & l) != 0L) 1076 jjstateSet[jjnewStateCnt++] = 49; 1077 break; 1078 case 51: 1079 if ((0x8000000080L & l) != 0L) 1080 jjstateSet[jjnewStateCnt++] = 50; 1081 break; 1082 case 52: 1083 if ((0x400000004000L & l) != 0L) 1084 jjstateSet[jjnewStateCnt++] = 51; 1085 break; 1086 case 53: 1087 if ((0x2000000020L & l) != 0L) 1088 jjstateSet[jjnewStateCnt++] = 52; 1089 break; 1090 case 54: 1091 if ((0x200000002L & l) != 0L) 1092 jjAddStates(7, 8); 1093 break; 1094 case 55: 1095 if ((0x80000000800L & l) != 0L && kind > 42) 1096 kind = 42; 1097 break; 1098 case 56: 1099 if ((0x800000008L & l) != 0L) 1100 jjstateSet[jjnewStateCnt++] = 55; 1101 break; 1102 case 57: 1103 if ((0x200000002L & l) != 0L) 1104 jjstateSet[jjnewStateCnt++] = 56; 1105 break; 1106 case 58: 1107 if ((0x4000000040000L & l) != 0L) 1108 jjstateSet[jjnewStateCnt++] = 57; 1109 break; 1110 case 59: 1111 if ((0x10000000100000L & l) != 0L) 1112 jjstateSet[jjnewStateCnt++] = 58; 1113 break; 1114 case 61: 1115 if ((0x200000002000000L & l) != 0L) 1116 jjstateSet[jjnewStateCnt++] = 60; 1117 break; 1118 case 62: 1119 if ((0x400000004000L & l) != 0L) 1120 jjstateSet[jjnewStateCnt++] = 61; 1121 break; 1122 case 63: 1123 if ((0x200000002L & l) != 0L) 1124 jjstateSet[jjnewStateCnt++] = 62; 1125 break; 1126 case 65: 1127 if ((0x400000004000L & l) != 0L) 1128 jjstateSet[jjnewStateCnt++] = 64; 1129 break; 1130 case 66: 1131 if ((0x20000000200L & l) != 0L) 1132 jjstateSet[jjnewStateCnt++] = 65; 1133 break; 1134 case 68: 1135 if ((0x2000000020L & l) != 0L) 1136 jjstateSet[jjnewStateCnt++] = 67; 1137 break; 1138 case 69: 1139 if ((0x4000000040000L & l) != 0L) 1140 jjstateSet[jjnewStateCnt++] = 68; 1141 break; 1142 case 70: 1143 if ((0x20000000200000L & l) != 0L) 1144 jjstateSet[jjnewStateCnt++] = 69; 1145 break; 1146 case 71: 1147 if ((0x10000000100000L & l) != 0L) 1148 jjstateSet[jjnewStateCnt++] = 70; 1149 break; 1150 case 72: 1151 if ((0x200000002L & l) != 0L) 1152 jjstateSet[jjnewStateCnt++] = 71; 1153 break; 1154 case 73: 1155 if ((0x2000000020L & l) != 0L) 1156 jjstateSet[jjnewStateCnt++] = 72; 1157 break; 1158 case 74: 1159 if ((0x4000000040L & l) != 0L) 1160 jjstateSet[jjnewStateCnt++] = 73; 1161 break; 1162 case 76: 1163 if ((0x80000000800L & l) != 0L) 1164 jjstateSet[jjnewStateCnt++] = 77; 1165 break; 1166 case 78: 1167 if ((0x800000008L & l) != 0L) 1168 jjstateSet[jjnewStateCnt++] = 76; 1169 break; 1170 case 79: 1171 if ((0x200000002L & l) != 0L) 1172 jjstateSet[jjnewStateCnt++] = 78; 1173 break; 1174 case 80: 1175 if ((0x4000000040000L & l) != 0L) 1176 jjstateSet[jjnewStateCnt++] = 79; 1177 break; 1178 case 81: 1179 if ((0x10000000100000L & l) != 0L) 1180 jjstateSet[jjnewStateCnt++] = 80; 1181 break; 1182 case 83: 1183 if ((0x400000004000L & l) != 0L) 1184 jjstateSet[jjnewStateCnt++] = 82; 1185 break; 1186 case 84: 1187 if ((0x20000000200L & l) != 0L) 1188 jjstateSet[jjnewStateCnt++] = 83; 1189 break; 1190 case 86: 1191 if ((0x2000000020L & l) != 0L) 1192 jjstateSet[jjnewStateCnt++] = 85; 1193 break; 1194 case 87: 1195 if ((0x4000000040000L & l) != 0L) 1196 jjstateSet[jjnewStateCnt++] = 86; 1197 break; 1198 case 88: 1199 if ((0x20000000200000L & l) != 0L) 1200 jjstateSet[jjnewStateCnt++] = 87; 1201 break; 1202 case 89: 1203 if ((0x10000000100000L & l) != 0L) 1204 jjstateSet[jjnewStateCnt++] = 88; 1205 break; 1206 case 90: 1207 if ((0x200000002L & l) != 0L) 1208 jjstateSet[jjnewStateCnt++] = 89; 1209 break; 1210 case 91: 1211 if ((0x2000000020L & l) != 0L) 1212 jjstateSet[jjnewStateCnt++] = 90; 1213 break; 1214 case 92: 1215 if ((0x4000000040L & l) != 0L) 1216 jjstateSet[jjnewStateCnt++] = 91; 1217 break; 1218 case 94: 1219 if ((0x7fffffe87fffffeL & l) == 0L) 1220 break; 1221 if (kind > 43) 1222 kind = 43; 1223 jjCheckNAddStates(3, 6); 1224 break; 1225 case 95: 1226 if ((0x7fffffe87fffffeL & l) == 0L) 1227 break; 1228 if (kind > 43) 1229 kind = 43; 1230 jjCheckNAdd(95); 1231 break; 1232 case 96: 1233 if ((0x7fffffe87fffffeL & l) != 0L) 1234 jjCheckNAddStates(0, 2); 1235 break; 1236 default : break; 1237 } 1238 } while(i != startsAt); 1239 } 1240 else 1241 { 1242 int i2 = (curChar & 0xff) >> 6; 1243 long l2 = 1L << (curChar & 077); 1244 MatchLoop: do 1245 { 1246 switch(jjstateSet[--i]) 1247 { 1248 default : break; 1249 } 1250 } while(i != startsAt); 1251 } 1252 if (kind != 0x7fffffff) 1253 { 1254 jjmatchedKind = kind; 1255 jjmatchedPos = curPos; 1256 kind = 0x7fffffff; 1257 } 1258 ++curPos; 1259 if ((i = jjnewStateCnt) == (startsAt = 99 - (jjnewStateCnt = startsAt))) 1260 return curPos; 1261 try { curChar = input_stream.readChar(); } 1262 catch(java.io.IOException e) { return curPos; } 1263 } 1264 } 1265 static final int[] jjnextStates = { 1266 96, 97, 98, 95, 96, 97, 98, 75, 93, 45, 53, 30, 42, 22, 26, 1267 }; 1268 public static final String[] jjstrLiteralImages = { 1269 "", null, null, null, null, null, null, null, "\75", "\54", null, null, "\74", 1270 null, "\76", null, null, "\173", "\175", "\50", "\51", "\133", "\135", "\176", null, 1271 null, null, null, null, null, "\46\46", "\174\174", "\55", "\41", "\77", "\53", 1272 "\52", "\12", null, null, null, null, null, null, null, null, null, "\73", }; 1273 public static final String[] lexStateNames = { 1274 "DEFAULT", 1275 }; 1276 static final long[] jjtoToken = { 1277 0xffffffffff01L, 1278 }; 1279 static final long[] jjtoSkip = { 1280 0x3eL, 1281 }; 1282 protected SimpleCharStream input_stream; 1283 private final int[] jjrounds = new int[99]; 1284 private final int[] jjstateSet = new int[198]; 1285 protected char curChar; 1286 public ParserTokenManager(SimpleCharStream stream) 1287 { 1288 if (SimpleCharStream.staticFlag) 1289 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 1290 input_stream = stream; 1291 } 1292 public ParserTokenManager(SimpleCharStream stream, int lexState) 1293 { 1294 this(stream); 1295 SwitchTo(lexState); 1296 } 1297 public void ReInit(SimpleCharStream stream) 1298 { 1299 jjmatchedPos = jjnewStateCnt = 0; 1300 curLexState = defaultLexState; 1301 input_stream = stream; 1302 ReInitRounds(); 1303 } 1304 private final void ReInitRounds() 1305 { 1306 int i; 1307 jjround = 0x80000001; 1308 for (i = 99; i-- > 0;) 1309 jjrounds[i] = 0x80000000; 1310 } 1311 public void ReInit(SimpleCharStream stream, int lexState) 1312 { 1313 ReInit(stream); 1314 SwitchTo(lexState); 1315 } 1316 public void SwitchTo(int lexState) 1317 { 1318 if (lexState >= 1 || lexState < 0) 1319 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 1320 else 1321 curLexState = lexState; 1322 } 1323 1324 protected Token jjFillToken() 1325 { 1326 Token t = Token.newToken(jjmatchedKind); 1327 t.kind = jjmatchedKind; 1328 String im = jjstrLiteralImages[jjmatchedKind]; 1329 t.image = (im == null) ? input_stream.GetImage() : im; 1330 t.beginLine = input_stream.getBeginLine(); 1331 t.beginColumn = input_stream.getBeginColumn(); 1332 t.endLine = input_stream.getEndLine(); 1333 t.endColumn = input_stream.getEndColumn(); 1334 return t; 1335 } 1336 1337 int curLexState = 0; 1338 int defaultLexState = 0; 1339 int jjnewStateCnt; 1340 int jjround; 1341 int jjmatchedPos; 1342 int jjmatchedKind; 1343 1344 public Token getNextToken() 1345 { 1346 int kind; 1347 Token specialToken = null; 1348 Token matchedToken; 1349 int curPos = 0; 1350 1351 EOFLoop : 1352 for (;;) 1353 { 1354 try 1355 { 1356 curChar = input_stream.BeginToken(); 1357 } 1358 catch(java.io.IOException e) 1359 { 1360 jjmatchedKind = 0; 1361 matchedToken = jjFillToken(); 1362 return matchedToken; 1363 } 1364 1365 try { input_stream.backup(0); 1366 while (curChar <= 32 && (0x100002200L & (1L << curChar)) != 0L) 1367 curChar = input_stream.BeginToken(); 1368 } 1369 catch (java.io.IOException e1) { continue EOFLoop; } 1370 jjmatchedKind = 0x7fffffff; 1371 jjmatchedPos = 0; 1372 curPos = jjMoveStringLiteralDfa0_0(); 1373 if (jjmatchedKind != 0x7fffffff) 1374 { 1375 if (jjmatchedPos + 1 < curPos) 1376 input_stream.backup(curPos - jjmatchedPos - 1); 1377 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 1378 { 1379 matchedToken = jjFillToken(); 1380 return matchedToken; 1381 } 1382 else 1383 { 1384 continue EOFLoop; 1385 } 1386 } 1387 int error_line = input_stream.getEndLine(); 1388 int error_column = input_stream.getEndColumn(); 1389 String error_after = null; 1390 boolean EOFSeen = false; 1391 try { input_stream.readChar(); input_stream.backup(1); } 1392 catch (java.io.IOException e1) { 1393 EOFSeen = true; 1394 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 1395 if (curChar == '\n' || curChar == '\r') { 1396 error_line++; 1397 error_column = 0; 1398 } 1399 else 1400 error_column++; 1401 } 1402 if (!EOFSeen) { 1403 input_stream.backup(1); 1404 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 1405 } 1406 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 1407 } 1408 } 1409 1410 }