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 public class BnfParserTokenManager implements BnfParserConstants
007 {
008 public java.io.PrintStream debugStream = System.out;
009 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
010 private final int jjStopStringLiteralDfa_0(int pos, long active0)
011 {
012 switch (pos)
013 {
014 case 0:
015 if ((active0 & 0x800L) != 0L)
016 return 8;
017 return -1;
018 default :
019 return -1;
020 }
021 }
022 private final int jjStartNfa_0(int pos, long active0)
023 {
024 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
025 }
026 private final int jjStopAtPos(int pos, int kind)
027 {
028 jjmatchedKind = kind;
029 jjmatchedPos = pos;
030 return pos + 1;
031 }
032 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
033 {
034 jjmatchedKind = kind;
035 jjmatchedPos = pos;
036 try { curChar = input_stream.readChar(); }
037 catch(java.io.IOException e) { return pos + 1; }
038 return jjMoveNfa_0(state, pos + 1);
039 }
040 private final int jjMoveStringLiteralDfa0_0()
041 {
042 switch(curChar)
043 {
044 case 34:
045 return jjStartNfaWithStates_0(0, 11, 8);
046 case 40:
047 return jjStopAtPos(0, 4);
048 case 41:
049 return jjStopAtPos(0, 5);
050 case 42:
051 return jjStopAtPos(0, 8);
052 case 43:
053 return jjStopAtPos(0, 7);
054 case 47:
055 return jjMoveStringLiteralDfa1_0(0x180000L);
056 case 58:
057 return jjMoveStringLiteralDfa1_0(0x200L);
058 case 63:
059 return jjStopAtPos(0, 6);
060 case 124:
061 return jjStopAtPos(0, 10);
062 default :
063 return jjMoveNfa_0(0, 0);
064 }
065 }
066 private final int jjMoveStringLiteralDfa1_0(long active0)
067 {
068 try { curChar = input_stream.readChar(); }
069 catch(java.io.IOException e) {
070 jjStopStringLiteralDfa_0(0, active0);
071 return 1;
072 }
073 switch(curChar)
074 {
075 case 42:
076 if ((active0 & 0x100000L) != 0L)
077 return jjStopAtPos(1, 20);
078 break;
079 case 47:
080 if ((active0 & 0x80000L) != 0L)
081 return jjStopAtPos(1, 19);
082 break;
083 case 58:
084 return jjMoveStringLiteralDfa2_0(active0, 0x200L);
085 default :
086 break;
087 }
088 return jjStartNfa_0(0, active0);
089 }
090 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
091 {
092 if (((active0 &= old0)) == 0L)
093 return jjStartNfa_0(0, old0);
094 try { curChar = input_stream.readChar(); }
095 catch(java.io.IOException e) {
096 jjStopStringLiteralDfa_0(1, active0);
097 return 2;
098 }
099 switch(curChar)
100 {
101 case 61:
102 if ((active0 & 0x200L) != 0L)
103 return jjStopAtPos(2, 9);
104 break;
105 default :
106 break;
107 }
108 return jjStartNfa_0(1, active0);
109 }
110 private final void jjCheckNAdd(int state)
111 {
112 if (jjrounds[state] != jjround)
113 {
114 jjstateSet[jjnewStateCnt++] = state;
115 jjrounds[state] = jjround;
116 }
117 }
118 private final void jjAddStates(int start, int end)
119 {
120 do {
121 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
122 } while (start++ != end);
123 }
124 private final void jjCheckNAddTwoStates(int state1, int state2)
125 {
126 jjCheckNAdd(state1);
127 jjCheckNAdd(state2);
128 }
129 private final void jjCheckNAddStates(int start, int end)
130 {
131 do {
132 jjCheckNAdd(jjnextStates[start]);
133 } while (start++ != end);
134 }
135 private final void jjCheckNAddStates(int start)
136 {
137 jjCheckNAdd(jjnextStates[start]);
138 jjCheckNAdd(jjnextStates[start + 1]);
139 }
140 static final long[] jjbitVec0 = {
141 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
142 };
143 static final long[] jjbitVec2 = {
144 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
145 };
146 static final long[] jjbitVec3 = {
147 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
148 };
149 static final long[] jjbitVec4 = {
150 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
151 };
152 static final long[] jjbitVec5 = {
153 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
154 };
155 static final long[] jjbitVec6 = {
156 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
157 };
158 static final long[] jjbitVec7 = {
159 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
160 };
161 static final long[] jjbitVec8 = {
162 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
163 };
164 private final int jjMoveNfa_0(int startState, int curPos)
165 {
166 int[] nextStates;
167 int startsAt = 0;
168 jjnewStateCnt = 8;
169 int i = 1;
170 jjstateSet[0] = startState;
171 int j, kind = 0x7fffffff;
172 for (;;)
173 {
174 if (++jjround == 0x7fffffff)
175 ReInitRounds();
176 if (curChar < 64)
177 {
178 long l = 1L << curChar;
179 MatchLoop: do
180 {
181 switch(jjstateSet[--i])
182 {
183 case 0:
184 if (curChar == 34)
185 jjCheckNAddTwoStates(6, 7);
186 else if (curChar == 60)
187 jjCheckNAdd(3);
188 else if (curChar == 36)
189 {
190 if (kind > 1)
191 kind = 1;
192 jjCheckNAdd(1);
193 }
194 break;
195 case 8:
196 if ((0xfffffffbffffffffL & l) != 0L)
197 jjCheckNAddTwoStates(6, 7);
198 else if (curChar == 34)
199 {
200 if (kind > 13)
201 kind = 13;
202 jjstateSet[jjnewStateCnt++] = 5;
203 }
204 break;
205 case 1:
206 if ((0x3ff001000000000L & l) == 0L)
207 break;
208 if (kind > 1)
209 kind = 1;
210 jjCheckNAdd(1);
211 break;
212 case 2:
213 if (curChar == 60)
214 jjCheckNAdd(3);
215 break;
216 case 3:
217 if ((0x3ff001000000000L & l) != 0L)
218 jjCheckNAddTwoStates(3, 4);
219 break;
220 case 4:
221 if (curChar == 62 && kind > 12)
222 kind = 12;
223 break;
224 case 5:
225 if (curChar == 34)
226 jjCheckNAddTwoStates(6, 7);
227 break;
228 case 6:
229 if ((0xfffffffbffffffffL & l) != 0L)
230 jjCheckNAddTwoStates(6, 7);
231 break;
232 case 7:
233 if (curChar != 34)
234 break;
235 if (kind > 13)
236 kind = 13;
237 jjstateSet[jjnewStateCnt++] = 5;
238 break;
239 default : break;
240 }
241 } while(i != startsAt);
242 }
243 else if (curChar < 128)
244 {
245 long l = 1L << (curChar & 077);
246 MatchLoop: do
247 {
248 switch(jjstateSet[--i])
249 {
250 case 0:
251 case 1:
252 if ((0x7fffffe87fffffeL & l) == 0L)
253 break;
254 if (kind > 1)
255 kind = 1;
256 jjCheckNAdd(1);
257 break;
258 case 8:
259 case 6:
260 jjCheckNAddTwoStates(6, 7);
261 break;
262 case 3:
263 if ((0x7fffffe87fffffeL & l) != 0L)
264 jjAddStates(0, 1);
265 break;
266 default : break;
267 }
268 } while(i != startsAt);
269 }
270 else
271 {
272 int hiByte = (int)(curChar >> 8);
273 int i1 = hiByte >> 6;
274 long l1 = 1L << (hiByte & 077);
275 int i2 = (curChar & 0xff) >> 6;
276 long l2 = 1L << (curChar & 077);
277 MatchLoop: do
278 {
279 switch(jjstateSet[--i])
280 {
281 case 0:
282 case 1:
283 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
284 break;
285 if (kind > 1)
286 kind = 1;
287 jjCheckNAdd(1);
288 break;
289 case 8:
290 case 6:
291 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
292 jjCheckNAddTwoStates(6, 7);
293 break;
294 case 3:
295 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
296 jjAddStates(0, 1);
297 break;
298 default : break;
299 }
300 } while(i != startsAt);
301 }
302 if (kind != 0x7fffffff)
303 {
304 jjmatchedKind = kind;
305 jjmatchedPos = curPos;
306 kind = 0x7fffffff;
307 }
308 ++curPos;
309 if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
310 return curPos;
311 try { curChar = input_stream.readChar(); }
312 catch(java.io.IOException e) { return curPos; }
313 }
314 }
315 private final int jjMoveStringLiteralDfa0_2()
316 {
317 switch(curChar)
318 {
319 case 42:
320 return jjMoveStringLiteralDfa1_2(0x400000L);
321 default :
322 return 1;
323 }
324 }
325 private final int jjMoveStringLiteralDfa1_2(long active0)
326 {
327 try { curChar = input_stream.readChar(); }
328 catch(java.io.IOException e) {
329 return 1;
330 }
331 switch(curChar)
332 {
333 case 47:
334 if ((active0 & 0x400000L) != 0L)
335 return jjStopAtPos(1, 22);
336 break;
337 default :
338 return 2;
339 }
340 return 2;
341 }
342 private final int jjMoveStringLiteralDfa0_1()
343 {
344 return jjMoveNfa_1(0, 0);
345 }
346 private final int jjMoveNfa_1(int startState, int curPos)
347 {
348 int[] nextStates;
349 int startsAt = 0;
350 jjnewStateCnt = 3;
351 int i = 1;
352 jjstateSet[0] = startState;
353 int j, kind = 0x7fffffff;
354 for (;;)
355 {
356 if (++jjround == 0x7fffffff)
357 ReInitRounds();
358 if (curChar < 64)
359 {
360 long l = 1L << curChar;
361 MatchLoop: do
362 {
363 switch(jjstateSet[--i])
364 {
365 case 0:
366 if ((0x2400L & l) != 0L)
367 {
368 if (kind > 21)
369 kind = 21;
370 }
371 if (curChar == 13)
372 jjstateSet[jjnewStateCnt++] = 1;
373 break;
374 case 1:
375 if (curChar == 10 && kind > 21)
376 kind = 21;
377 break;
378 case 2:
379 if (curChar == 13)
380 jjstateSet[jjnewStateCnt++] = 1;
381 break;
382 default : break;
383 }
384 } while(i != startsAt);
385 }
386 else if (curChar < 128)
387 {
388 long l = 1L << (curChar & 077);
389 MatchLoop: do
390 {
391 switch(jjstateSet[--i])
392 {
393 default : break;
394 }
395 } while(i != startsAt);
396 }
397 else
398 {
399 int hiByte = (int)(curChar >> 8);
400 int i1 = hiByte >> 6;
401 long l1 = 1L << (hiByte & 077);
402 int i2 = (curChar & 0xff) >> 6;
403 long l2 = 1L << (curChar & 077);
404 MatchLoop: do
405 {
406 switch(jjstateSet[--i])
407 {
408 default : break;
409 }
410 } while(i != startsAt);
411 }
412 if (kind != 0x7fffffff)
413 {
414 jjmatchedKind = kind;
415 jjmatchedPos = curPos;
416 kind = 0x7fffffff;
417 }
418 ++curPos;
419 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
420 return curPos;
421 try { curChar = input_stream.readChar(); }
422 catch(java.io.IOException e) { return curPos; }
423 }
424 }
425 static final int[] jjnextStates = {
426 3, 4,
427 };
428 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
429 {
430 switch(hiByte)
431 {
432 case 0:
433 return ((jjbitVec2[i2] & l2) != 0L);
434 case 48:
435 return ((jjbitVec3[i2] & l2) != 0L);
436 case 49:
437 return ((jjbitVec4[i2] & l2) != 0L);
438 case 51:
439 return ((jjbitVec5[i2] & l2) != 0L);
440 case 61:
441 return ((jjbitVec6[i2] & l2) != 0L);
442 default :
443 if ((jjbitVec0[i1] & l1) != 0L)
444 return true;
445 return false;
446 }
447 }
448 private 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 ((jjbitVec8[i2] & l2) != 0L);
454 default :
455 if ((jjbitVec7[i1] & l1) != 0L)
456 return true;
457 return false;
458 }
459 }
460 public static final String[] jjstrLiteralImages = {
461 "", null, null, null, "\50", "\51", "\77", "\53", "\52", "\72\72\75", "\174",
462 "\42", null, null, null, null, null, null, null, null, null, null, null, null, };
463 public static final String[] lexStateNames = {
464 "DEFAULT",
465 "IN_SINGLE_LINE_COMMENT",
466 "IN_MULTI_LINE_COMMENT",
467 };
468 public static final int[] jjnewLexState = {
469 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1,
470 };
471 static final long[] jjtoToken = {
472 0x3ff3L,
473 };
474 static final long[] jjtoSkip = {
475 0x67c000L,
476 };
477 static final long[] jjtoSpecial = {
478 0x600000L,
479 };
480 static final long[] jjtoMore = {
481 0x980000L,
482 };
483 protected SimpleCharStream input_stream;
484 private final int[] jjrounds = new int[8];
485 private final int[] jjstateSet = new int[16];
486 StringBuffer image;
487 int jjimageLen;
488 int lengthOfMatch;
489 protected char curChar;
490 public BnfParserTokenManager(SimpleCharStream stream){
491 if (SimpleCharStream.staticFlag)
492 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
493 input_stream = stream;
494 }
495 public BnfParserTokenManager(SimpleCharStream stream, int lexState){
496 this(stream);
497 SwitchTo(lexState);
498 }
499 public void ReInit(SimpleCharStream stream)
500 {
501 jjmatchedPos = jjnewStateCnt = 0;
502 curLexState = defaultLexState;
503 input_stream = stream;
504 ReInitRounds();
505 }
506 private final void ReInitRounds()
507 {
508 int i;
509 jjround = 0x80000001;
510 for (i = 8; i-- > 0;)
511 jjrounds[i] = 0x80000000;
512 }
513 public void ReInit(SimpleCharStream stream, int lexState)
514 {
515 ReInit(stream);
516 SwitchTo(lexState);
517 }
518 public void SwitchTo(int lexState)
519 {
520 if (lexState >= 3 || lexState < 0)
521 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
522 else
523 curLexState = lexState;
524 }
525
526 protected Token jjFillToken()
527 {
528 Token t = Token.newToken(jjmatchedKind);
529 t.kind = jjmatchedKind;
530 String im = jjstrLiteralImages[jjmatchedKind];
531 t.image = (im == null) ? input_stream.GetImage() : im;
532 t.beginLine = input_stream.getBeginLine();
533 t.beginColumn = input_stream.getBeginColumn();
534 t.endLine = input_stream.getEndLine();
535 t.endColumn = input_stream.getEndColumn();
536 return t;
537 }
538
539 int curLexState = 0;
540 int defaultLexState = 0;
541 int jjnewStateCnt;
542 int jjround;
543 int jjmatchedPos;
544 int jjmatchedKind;
545
546 public Token getNextToken()
547 {
548 int kind;
549 Token specialToken = null;
550 Token matchedToken;
551 int curPos = 0;
552
553 EOFLoop :
554 for (;;)
555 {
556 try
557 {
558 curChar = input_stream.BeginToken();
559 }
560 catch(java.io.IOException e)
561 {
562 jjmatchedKind = 0;
563 matchedToken = jjFillToken();
564 matchedToken.specialToken = specialToken;
565 return matchedToken;
566 }
567 image = null;
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 }