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