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 }