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