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