001 /* Generated By:JavaCC: Do not edit this line. TelemetryLanguageParserImplTokenManager.java */ 002 package org.hackystat.telemetry.analyzer.language.parser.impl; 003 004 public class TelemetryLanguageParserImplTokenManager implements TelemetryLanguageParserImplConstants 005 { 006 public java.io.PrintStream debugStream = System.out; 007 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } 008 private final int jjStopStringLiteralDfa_0(int pos, long active0) 009 { 010 switch (pos) 011 { 012 case 0: 013 if ((active0 & 0x3e0L) != 0L) 014 { 015 jjmatchedKind = 21; 016 return 1; 017 } 018 return -1; 019 case 1: 020 if ((active0 & 0x3e0L) != 0L) 021 { 022 jjmatchedKind = 21; 023 jjmatchedPos = 1; 024 return 1; 025 } 026 return -1; 027 case 2: 028 if ((active0 & 0x3e0L) != 0L) 029 { 030 jjmatchedKind = 21; 031 jjmatchedPos = 2; 032 return 1; 033 } 034 return -1; 035 case 3: 036 if ((active0 & 0x100L) != 0L) 037 return 1; 038 if ((active0 & 0x2e0L) != 0L) 039 { 040 jjmatchedKind = 21; 041 jjmatchedPos = 3; 042 return 1; 043 } 044 return -1; 045 case 4: 046 if ((active0 & 0x2a0L) != 0L) 047 { 048 jjmatchedKind = 21; 049 jjmatchedPos = 4; 050 return 1; 051 } 052 if ((active0 & 0x40L) != 0L) 053 return 1; 054 return -1; 055 case 5: 056 if ((active0 & 0x20L) != 0L) 057 { 058 jjmatchedKind = 21; 059 jjmatchedPos = 5; 060 return 1; 061 } 062 if ((active0 & 0x280L) != 0L) 063 return 1; 064 return -1; 065 default : 066 return -1; 067 } 068 } 069 private final int jjStartNfa_0(int pos, long active0) 070 { 071 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 072 } 073 private final int jjStopAtPos(int pos, int kind) 074 { 075 jjmatchedKind = kind; 076 jjmatchedPos = pos; 077 return pos + 1; 078 } 079 private final int jjStartNfaWithStates_0(int pos, int kind, int state) 080 { 081 jjmatchedKind = kind; 082 jjmatchedPos = pos; 083 try { curChar = input_stream.readChar(); } 084 catch(java.io.IOException e) { return pos + 1; } 085 return jjMoveNfa_0(state, pos + 1); 086 } 087 private final int jjMoveStringLiteralDfa0_0() 088 { 089 switch(curChar) 090 { 091 case 9: 092 return jjStopAtPos(0, 2); 093 case 10: 094 return jjStopAtPos(0, 3); 095 case 13: 096 return jjStopAtPos(0, 4); 097 case 32: 098 return jjStopAtPos(0, 1); 099 case 34: 100 return jjStopAtPos(0, 16); 101 case 40: 102 return jjStopAtPos(0, 14); 103 case 41: 104 return jjStopAtPos(0, 15); 105 case 42: 106 return jjStopAtPos(0, 12); 107 case 43: 108 return jjStopAtPos(0, 10); 109 case 44: 110 return jjStopAtPos(0, 17); 111 case 45: 112 return jjStopAtPos(0, 11); 113 case 47: 114 return jjStopAtPos(0, 13); 115 case 59: 116 return jjStopAtPos(0, 18); 117 case 61: 118 return jjStopAtPos(0, 25); 119 case 99: 120 return jjMoveStringLiteralDfa1_0(0x40L); 121 case 100: 122 return jjMoveStringLiteralDfa1_0(0x100L); 123 case 114: 124 return jjMoveStringLiteralDfa1_0(0x80L); 125 case 115: 126 return jjMoveStringLiteralDfa1_0(0x20L); 127 case 121: 128 return jjMoveStringLiteralDfa1_0(0x200L); 129 case 123: 130 return jjStopAtPos(0, 26); 131 case 125: 132 return jjStopAtPos(0, 27); 133 default : 134 return jjMoveNfa_0(0, 0); 135 } 136 } 137 private final int jjMoveStringLiteralDfa1_0(long active0) 138 { 139 try { curChar = input_stream.readChar(); } 140 catch(java.io.IOException e) { 141 jjStopStringLiteralDfa_0(0, active0); 142 return 1; 143 } 144 switch(curChar) 145 { 146 case 45: 147 return jjMoveStringLiteralDfa2_0(active0, 0x200L); 148 case 101: 149 return jjMoveStringLiteralDfa2_0(active0, 0x80L); 150 case 104: 151 return jjMoveStringLiteralDfa2_0(active0, 0x40L); 152 case 114: 153 return jjMoveStringLiteralDfa2_0(active0, 0x100L); 154 case 116: 155 return jjMoveStringLiteralDfa2_0(active0, 0x20L); 156 default : 157 break; 158 } 159 return jjStartNfa_0(0, active0); 160 } 161 private final int jjMoveStringLiteralDfa2_0(long old0, long active0) 162 { 163 if (((active0 &= old0)) == 0L) 164 return jjStartNfa_0(0, old0); 165 try { curChar = input_stream.readChar(); } 166 catch(java.io.IOException e) { 167 jjStopStringLiteralDfa_0(1, active0); 168 return 2; 169 } 170 switch(curChar) 171 { 172 case 97: 173 return jjMoveStringLiteralDfa3_0(active0, 0x340L); 174 case 112: 175 return jjMoveStringLiteralDfa3_0(active0, 0x80L); 176 case 114: 177 return jjMoveStringLiteralDfa3_0(active0, 0x20L); 178 default : 179 break; 180 } 181 return jjStartNfa_0(1, active0); 182 } 183 private final int jjMoveStringLiteralDfa3_0(long old0, long active0) 184 { 185 if (((active0 &= old0)) == 0L) 186 return jjStartNfa_0(1, old0); 187 try { curChar = input_stream.readChar(); } 188 catch(java.io.IOException e) { 189 jjStopStringLiteralDfa_0(2, active0); 190 return 3; 191 } 192 switch(curChar) 193 { 194 case 101: 195 return jjMoveStringLiteralDfa4_0(active0, 0x20L); 196 case 111: 197 return jjMoveStringLiteralDfa4_0(active0, 0x80L); 198 case 114: 199 return jjMoveStringLiteralDfa4_0(active0, 0x40L); 200 case 119: 201 if ((active0 & 0x100L) != 0L) 202 return jjStartNfaWithStates_0(3, 8, 1); 203 break; 204 case 120: 205 return jjMoveStringLiteralDfa4_0(active0, 0x200L); 206 default : 207 break; 208 } 209 return jjStartNfa_0(2, active0); 210 } 211 private final int jjMoveStringLiteralDfa4_0(long old0, long active0) 212 { 213 if (((active0 &= old0)) == 0L) 214 return jjStartNfa_0(2, old0); 215 try { curChar = input_stream.readChar(); } 216 catch(java.io.IOException e) { 217 jjStopStringLiteralDfa_0(3, active0); 218 return 4; 219 } 220 switch(curChar) 221 { 222 case 97: 223 return jjMoveStringLiteralDfa5_0(active0, 0x20L); 224 case 105: 225 return jjMoveStringLiteralDfa5_0(active0, 0x200L); 226 case 114: 227 return jjMoveStringLiteralDfa5_0(active0, 0x80L); 228 case 116: 229 if ((active0 & 0x40L) != 0L) 230 return jjStartNfaWithStates_0(4, 6, 1); 231 break; 232 default : 233 break; 234 } 235 return jjStartNfa_0(3, active0); 236 } 237 private final int jjMoveStringLiteralDfa5_0(long old0, long active0) 238 { 239 if (((active0 &= old0)) == 0L) 240 return jjStartNfa_0(3, old0); 241 try { curChar = input_stream.readChar(); } 242 catch(java.io.IOException e) { 243 jjStopStringLiteralDfa_0(4, active0); 244 return 5; 245 } 246 switch(curChar) 247 { 248 case 109: 249 return jjMoveStringLiteralDfa6_0(active0, 0x20L); 250 case 115: 251 if ((active0 & 0x200L) != 0L) 252 return jjStartNfaWithStates_0(5, 9, 1); 253 break; 254 case 116: 255 if ((active0 & 0x80L) != 0L) 256 return jjStartNfaWithStates_0(5, 7, 1); 257 break; 258 default : 259 break; 260 } 261 return jjStartNfa_0(4, active0); 262 } 263 private final int jjMoveStringLiteralDfa6_0(long old0, long active0) 264 { 265 if (((active0 &= old0)) == 0L) 266 return jjStartNfa_0(4, old0); 267 try { curChar = input_stream.readChar(); } 268 catch(java.io.IOException e) { 269 jjStopStringLiteralDfa_0(5, active0); 270 return 6; 271 } 272 switch(curChar) 273 { 274 case 115: 275 if ((active0 & 0x20L) != 0L) 276 return jjStartNfaWithStates_0(6, 5, 1); 277 break; 278 default : 279 break; 280 } 281 return jjStartNfa_0(5, active0); 282 } 283 private final void jjCheckNAdd(int state) 284 { 285 if (jjrounds[state] != jjround) 286 { 287 jjstateSet[jjnewStateCnt++] = state; 288 jjrounds[state] = jjround; 289 } 290 } 291 292 private final void jjCheckNAddTwoStates(int state1, int state2) 293 { 294 jjCheckNAdd(state1); 295 jjCheckNAdd(state2); 296 } 297 private final void jjCheckNAddStates(int start, int end) 298 { 299 do { 300 jjCheckNAdd(jjnextStates[start]); 301 } while (start++ != end); 302 } 303 304 private final int jjMoveNfa_0(int startState, int curPos) 305 { 306 //int[] nextStates; 307 int startsAt = 0; 308 jjnewStateCnt = 7; 309 int i = 1; 310 jjstateSet[0] = startState; 311 int kind = 0x7fffffff; 312 for (;;) 313 { 314 if (++jjround == 0x7fffffff) 315 ReInitRounds(); 316 if (curChar < 64) 317 { 318 long l = 1L << curChar; 319 do 320 { 321 switch(jjstateSet[--i]) 322 { 323 case 0: 324 if ((0x3ff000000000000L & l) == 0L) 325 break; 326 if (kind > 19) 327 kind = 19; 328 jjCheckNAddStates(0, 2); 329 break; 330 case 1: 331 if ((0x3ff200000000000L & l) == 0L) 332 break; 333 if (kind > 21) 334 kind = 21; 335 jjstateSet[jjnewStateCnt++] = 1; 336 break; 337 case 3: 338 if ((0x3ff000000000000L & l) == 0L) 339 break; 340 if (kind > 19) 341 kind = 19; 342 jjCheckNAdd(3); 343 break; 344 case 4: 345 if ((0x3ff000000000000L & l) == 0L) 346 break; 347 if (kind > 20) 348 kind = 20; 349 jjCheckNAddTwoStates(4, 5); 350 break; 351 case 5: 352 if (curChar == 46) 353 jjCheckNAdd(6); 354 break; 355 case 6: 356 if ((0x3ff000000000000L & l) == 0L) 357 break; 358 if (kind > 20) 359 kind = 20; 360 jjCheckNAdd(6); 361 break; 362 default : break; 363 } 364 } while(i != startsAt); 365 } 366 else if (curChar < 128) 367 { 368 long l = 1L << (curChar & 077); 369 do 370 { 371 switch(jjstateSet[--i]) 372 { 373 case 0: 374 if ((0x7fffffe07fffffeL & l) == 0L) 375 break; 376 if (kind > 21) 377 kind = 21; 378 jjCheckNAdd(1); 379 break; 380 case 1: 381 if ((0x7fffffe87fffffeL & l) == 0L) 382 break; 383 if (kind > 21) 384 kind = 21; 385 jjCheckNAdd(1); 386 break; 387 default : break; 388 } 389 } while(i != startsAt); 390 } 391 else 392 { 393 //int i2 = (curChar & 0xff) >> 6; 394 //long l2 = 1L << (curChar & 077); 395 do 396 { 397 switch(jjstateSet[--i]) 398 { 399 default : break; 400 } 401 } while(i != startsAt); 402 } 403 if (kind != 0x7fffffff) 404 { 405 jjmatchedKind = kind; 406 jjmatchedPos = curPos; 407 kind = 0x7fffffff; 408 } 409 ++curPos; 410 if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt))) 411 return curPos; 412 try { curChar = input_stream.readChar(); } 413 catch(java.io.IOException e) { return curPos; } 414 } 415 } 416 private final int jjMoveStringLiteralDfa0_1() 417 { 418 return jjMoveNfa_1(0, 0); 419 } 420 static final long[] jjbitVec0 = { 421 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 422 }; 423 private final int jjMoveNfa_1(int startState, int curPos) 424 { 425 //int[] nextStates; 426 int startsAt = 0; 427 jjnewStateCnt = 1; 428 int i = 1; 429 jjstateSet[0] = startState; 430 int kind = 0x7fffffff; 431 for (;;) 432 { 433 if (++jjround == 0x7fffffff) 434 ReInitRounds(); 435 if (curChar < 64) 436 { 437 long l = 1L << curChar; 438 do 439 { 440 switch(jjstateSet[--i]) 441 { 442 case 0: 443 if ((0xfffffffbffffffffL & l) == 0L) 444 break; 445 kind = 24; 446 jjstateSet[jjnewStateCnt++] = 0; 447 break; 448 default : break; 449 } 450 } while(i != startsAt); 451 } 452 else if (curChar < 128) 453 { 454 //long l = 1L << (curChar & 077); 455 do 456 { 457 switch(jjstateSet[--i]) 458 { 459 case 0: 460 kind = 24; 461 jjstateSet[jjnewStateCnt++] = 0; 462 break; 463 default : break; 464 } 465 } while(i != startsAt); 466 } 467 else 468 { 469 int i2 = (curChar & 0xff) >> 6; 470 long l2 = 1L << (curChar & 077); 471 do 472 { 473 switch(jjstateSet[--i]) 474 { 475 case 0: 476 if ((jjbitVec0[i2] & l2) == 0L) 477 break; 478 if (kind > 24) 479 kind = 24; 480 jjstateSet[jjnewStateCnt++] = 0; 481 break; 482 default : break; 483 } 484 } while(i != startsAt); 485 } 486 if (kind != 0x7fffffff) 487 { 488 jjmatchedKind = kind; 489 jjmatchedPos = curPos; 490 kind = 0x7fffffff; 491 } 492 ++curPos; 493 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) 494 return curPos; 495 try { curChar = input_stream.readChar(); } 496 catch(java.io.IOException e) { return curPos; } 497 } 498 } 499 static final int[] jjnextStates = { 500 3, 4, 5, 501 }; 502 public static final String[] jjstrLiteralImages = { 503 "", null, null, null, null, "\163\164\162\145\141\155\163", 504 "\143\150\141\162\164", "\162\145\160\157\162\164", "\144\162\141\167", "\171\55\141\170\151\163", 505 "\53", "\55", "\52", "\57", "\50", "\51", "\42", "\54", "\73", null, null, null, null, 506 null, null, "\75", "\173", "\175", }; 507 public static final String[] lexStateNames = { 508 "DEFAULT", 509 "COMMENT", 510 }; 511 public static final int[] jjnewLexState = { 512 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 513 -1, -1, -1, 514 }; 515 static final long[] jjtoToken = { 516 0xf3fffe1L, 517 }; 518 static final long[] jjtoSkip = { 519 0x1eL, 520 }; 521 static final long[] jjtoSpecial = { 522 0x1eL, 523 }; 524 protected SimpleCharStream input_stream; 525 private final int[] jjrounds = new int[7]; 526 private final int[] jjstateSet = new int[14]; 527 StringBuffer image; 528 int jjimageLen; 529 int lengthOfMatch; 530 protected char curChar; 531 public TelemetryLanguageParserImplTokenManager(SimpleCharStream stream){ 532 if (SimpleCharStream.staticFlag) 533 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 534 input_stream = stream; 535 } 536 public TelemetryLanguageParserImplTokenManager(SimpleCharStream stream, int lexState){ 537 this(stream); 538 SwitchTo(lexState); 539 } 540 public void ReInit(SimpleCharStream stream) 541 { 542 jjmatchedPos = jjnewStateCnt = 0; 543 curLexState = defaultLexState; 544 input_stream = stream; 545 ReInitRounds(); 546 } 547 private final void ReInitRounds() 548 { 549 int i; 550 jjround = 0x80000001; 551 for (i = 7; i-- > 0;) 552 jjrounds[i] = 0x80000000; 553 } 554 public void ReInit(SimpleCharStream stream, int lexState) 555 { 556 ReInit(stream); 557 SwitchTo(lexState); 558 } 559 public void SwitchTo(int lexState) 560 { 561 if (lexState >= 2 || lexState < 0) 562 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 563 else 564 curLexState = lexState; 565 } 566 567 protected Token jjFillToken() 568 { 569 Token t = Token.newToken(jjmatchedKind); 570 t.kind = jjmatchedKind; 571 if (jjmatchedPos < 0) 572 { 573 if (image == null) 574 t.image = ""; 575 else 576 t.image = image.toString(); 577 t.beginLine = t.endLine = input_stream.getBeginLine(); 578 t.beginColumn = t.endColumn = input_stream.getBeginColumn(); 579 } 580 else 581 { 582 String im = jjstrLiteralImages[jjmatchedKind]; 583 t.image = (im == null) ? input_stream.GetImage() : im; 584 t.beginLine = input_stream.getBeginLine(); 585 t.beginColumn = input_stream.getBeginColumn(); 586 t.endLine = input_stream.getEndLine(); 587 t.endColumn = input_stream.getEndColumn(); 588 } 589 return t; 590 } 591 592 int curLexState = 0; 593 int defaultLexState = 0; 594 int jjnewStateCnt; 595 int jjround; 596 int jjmatchedPos; 597 int jjmatchedKind; 598 599 public Token getNextToken() 600 { 601 //int kind; 602 Token specialToken = null; 603 Token matchedToken; 604 int curPos = 0; 605 606 EOFLoop : 607 for (;;) 608 { 609 try 610 { 611 curChar = input_stream.BeginToken(); 612 } 613 catch(java.io.IOException e) 614 { 615 jjmatchedKind = 0; 616 matchedToken = jjFillToken(); 617 matchedToken.specialToken = specialToken; 618 return matchedToken; 619 } 620 image = null; 621 jjimageLen = 0; 622 623 switch(curLexState) 624 { 625 case 0: 626 jjmatchedKind = 0x7fffffff; 627 jjmatchedPos = 0; 628 curPos = jjMoveStringLiteralDfa0_0(); 629 break; 630 case 1: 631 jjmatchedKind = 24; 632 jjmatchedPos = -1; 633 curPos = 0; 634 curPos = jjMoveStringLiteralDfa0_1(); 635 break; 636 } 637 if (jjmatchedKind != 0x7fffffff) 638 { 639 if (jjmatchedPos + 1 < curPos) 640 input_stream.backup(curPos - jjmatchedPos - 1); 641 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 642 { 643 matchedToken = jjFillToken(); 644 matchedToken.specialToken = specialToken; 645 TokenLexicalActions(matchedToken); 646 if (jjnewLexState[jjmatchedKind] != -1) 647 curLexState = jjnewLexState[jjmatchedKind]; 648 return matchedToken; 649 } 650 else 651 { 652 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 653 { 654 matchedToken = jjFillToken(); 655 if (specialToken == null) 656 specialToken = matchedToken; 657 else 658 { 659 matchedToken.specialToken = specialToken; 660 specialToken = (specialToken.next = matchedToken); 661 } 662 } 663 if (jjnewLexState[jjmatchedKind] != -1) 664 curLexState = jjnewLexState[jjmatchedKind]; 665 continue EOFLoop; 666 } 667 } 668 int error_line = input_stream.getEndLine(); 669 int error_column = input_stream.getEndColumn(); 670 String error_after = null; 671 boolean EOFSeen = false; 672 try { input_stream.readChar(); input_stream.backup(1); } 673 catch (java.io.IOException e1) { 674 EOFSeen = true; 675 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 676 if (curChar == '\n' || curChar == '\r') { 677 error_line++; 678 error_column = 0; 679 } 680 else 681 error_column++; 682 } 683 if (!EOFSeen) { 684 input_stream.backup(1); 685 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 686 } 687 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 688 } 689 } 690 691 int[] jjemptyLineNo = new int[2]; 692 int[] jjemptyColNo = new int[2]; 693 boolean[] jjbeenHere = new boolean[2]; 694 void TokenLexicalActions(Token matchedToken) 695 { 696 switch(jjmatchedKind) 697 { 698 case 24 : 699 if (jjmatchedPos == -1) 700 { 701 if (jjbeenHere[1] && 702 jjemptyLineNo[1] == input_stream.getBeginLine() && 703 jjemptyColNo[1] == input_stream.getBeginColumn()) 704 throw new TokenMgrError(("Error: Bailing out of infinite loop caused by repeated empty string matches at line " + input_stream.getBeginLine() + ", column " + input_stream.getBeginColumn() + "."), TokenMgrError.LOOP_DETECTED); 705 jjemptyLineNo[1] = input_stream.getBeginLine(); 706 jjemptyColNo[1] = input_stream.getBeginColumn(); 707 jjbeenHere[1] = true; 708 } 709 break; 710 default : 711 break; 712 } 713 } 714 }