|
1
2 package de.gulden.util.javasource.jjt;
3 import de.gulden.util.javasource.SourceParser;
4 import java.io.*;
5
6 public class JavadocParserTokenManager implements JavadocParserConstants
7 {
8 public java.io.PrintStream  debugStream = System.out;
9 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
10 private final int jjStopStringLiteralDfa_0(int pos, long active0)
11 {
12 switch (pos)
13 {
14 case 0:
15 if ((active0 & 0x3ff00L) != 0L)
16 {
17 jjmatchedKind = 18;
18 jjmatchedPos = 0;
19 return 3;
20 }
21 if ((active0 & 0xc0L) != 0L)
22 return 3;
23 return -1;
24 case 1:
25 if ((active0 & 0x3ff00L) != 0L)
26 {
27 jjmatchedKind = 18;
28 jjmatchedPos = 1;
29 return 3;
30 }
31 if ((active0 & 0x40L) != 0L)
32 return 3;
33 return -1;
34 case 2:
35 if ((active0 & 0x1ff00L) != 0L)
36 {
37 jjmatchedKind = 18;
38 jjmatchedPos = 2;
39 return 3;
40 }
41 if ((active0 & 0x20000L) != 0L)
42 return 3;
43 return -1;
44 case 3:
45 if ((active0 & 0x1df00L) != 0L)
46 {
47 jjmatchedKind = 18;
48 jjmatchedPos = 3;
49 return 3;
50 }
51 if ((active0 & 0x2000L) != 0L)
52 return 3;
53 return -1;
54 case 4:
55 if ((active0 & 0x1df00L) != 0L)
56 {
57 jjmatchedKind = 18;
58 jjmatchedPos = 4;
59 return 3;
60 }
61 return -1;
62 case 5:
63 if ((active0 & 0x4800L) != 0L)
64 return 3;
65 if ((active0 & 0x19700L) != 0L)
66 {
67 jjmatchedKind = 18;
68 jjmatchedPos = 5;
69 return 3;
70 }
71 return -1;
72 case 6:
73 if ((active0 & 0x10600L) != 0L)
74 {
75 jjmatchedKind = 18;
76 jjmatchedPos = 6;
77 return 3;
78 }
79 if ((active0 & 0x9100L) != 0L)
80 return 3;
81 return -1;
82 case 7:
83 if ((active0 & 0x10000L) != 0L)
84 return 3;
85 if ((active0 & 0x600L) != 0L)
86 {
87 jjmatchedKind = 18;
88 jjmatchedPos = 7;
89 return 3;
90 }
91 return -1;
92 case 8:
93 if ((active0 & 0x600L) != 0L)
94 {
95 jjmatchedKind = 18;
96 jjmatchedPos = 8;
97 return 3;
98 }
99 return -1;
100 case 9:
101 if ((active0 & 0x400L) != 0L)
102 return 3;
103 if ((active0 & 0x200L) != 0L)
104 {
105 jjmatchedKind = 18;
106 jjmatchedPos = 9;
107 return 3;
108 }
109 return -1;
110 default :
111 return -1;
112 }
113 }
114 private final int jjStartNfa_0(int pos, long active0)
115 {
116 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
117 }
118 private final int jjStopAtPos(int pos, int kind)
119 {
120 jjmatchedKind = kind;
121 jjmatchedPos = pos;
122 return pos + 1;
123 }
124 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
125 {
126 jjmatchedKind = kind;
127 jjmatchedPos = pos;
128 try { curChar = input_stream.readChar(); }
129 catch(java.io.IOException e) { return pos + 1; }
130 return jjMoveNfa_0(state, pos + 1);
131 }
132 private final int jjMoveStringLiteralDfa0_0()
133 {
134 switch(curChar)
135 {
136 case 10:
137 return jjStopAtPos(0, 4);
138 case 42:
139 {
140 jjmatchedKind = 7;
141 jjmatchedPos = 0;
142 }
143 return jjMoveStringLiteralDfa1_0(0x40L);
144 case 64:
145 return jjMoveStringLiteralDfa1_0(0x3ff00L);
146 default :
147 return jjMoveNfa_0(2, 0);
148 }
149 }
150 private final int jjMoveStringLiteralDfa1_0(long active0)
151 {
152 try { curChar = input_stream.readChar(); }
153 catch(java.io.IOException e) {
154 jjStopStringLiteralDfa_0(0, active0);
155 return 1;
156 }
157 switch(curChar)
158 {
159 case 47:
160 if ((active0 & 0x40L) != 0L)
161 return jjStartNfaWithStates_0(1, 6, 3);
162 break;
163 case 97:
164 return jjMoveStringLiteralDfa2_0(active0, 0x100L);
165 case 100:
166 return jjMoveStringLiteralDfa2_0(active0, 0x200L);
167 case 101:
168 return jjMoveStringLiteralDfa2_0(active0, 0x400L);
169 case 105:
170 return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
171 case 112:
172 return jjMoveStringLiteralDfa2_0(active0, 0x800L);
173 case 114:
174 return jjMoveStringLiteralDfa2_0(active0, 0x1000L);
175 case 115:
176 return jjMoveStringLiteralDfa2_0(active0, 0x6000L);
177 case 116:
178 return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
179 case 118:
180 return jjMoveStringLiteralDfa2_0(active0, 0x10000L);
181 default :
182 break;
183 }
184 return jjStartNfa_0(0, active0);
185 }
186 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
187 {
188 if (((active0 &= old0)) == 0L)
189 return jjStartNfa_0(0, old0);
190 try { curChar = input_stream.readChar(); }
191 catch(java.io.IOException e) {
192 jjStopStringLiteralDfa_0(1, active0);
193 return 2;
194 }
195 switch(curChar)
196 {
197 case 97:
198 return jjMoveStringLiteralDfa3_0(active0, 0x800L);
199 case 100:
200 if ((active0 & 0x20000L) != 0L)
201 return jjStartNfaWithStates_0(2, 17, 3);
202 break;
203 case 101:
204 return jjMoveStringLiteralDfa3_0(active0, 0x13200L);
205 case 104:
206 return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
207 case 105:
208 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
209 case 117:
210 return jjMoveStringLiteralDfa3_0(active0, 0x100L);
211 case 120:
212 return jjMoveStringLiteralDfa3_0(active0, 0x400L);
213 default :
214 break;
215 }
216 return jjStartNfa_0(1, active0);
217 }
218 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
219 {
220 if (((active0 &= old0)) == 0L)
221 return jjStartNfa_0(1, old0);
222 try { curChar = input_stream.readChar(); }
223 catch(java.io.IOException e) {
224 jjStopStringLiteralDfa_0(2, active0);
225 return 3;
226 }
227 switch(curChar)
228 {
229 case 99:
230 return jjMoveStringLiteralDfa4_0(active0, 0x400L);
231 case 101:
232 if ((active0 & 0x2000L) != 0L)
233 return jjStartNfaWithStates_0(3, 13, 3);
234 break;
235 case 110:
236 return jjMoveStringLiteralDfa4_0(active0, 0x4000L);
237 case 112:
238 return jjMoveStringLiteralDfa4_0(active0, 0x200L);
239 case 114:
240 return jjMoveStringLiteralDfa4_0(active0, 0x18800L);
241 case 116:
242 return jjMoveStringLiteralDfa4_0(active0, 0x1100L);
243 default :
244 break;
245 }
246 return jjStartNfa_0(2, active0);
247 }
248 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
249 {
250 if (((active0 &= old0)) == 0L)
251 return jjStartNfa_0(2, old0);
252 try { curChar = input_stream.readChar(); }
253 catch(java.io.IOException e) {
254 jjStopStringLiteralDfa_0(3, active0);
255 return 4;
256 }
257 switch(curChar)
258 {
259 case 97:
260 return jjMoveStringLiteralDfa5_0(active0, 0x800L);
261 case 99:
262 return jjMoveStringLiteralDfa5_0(active0, 0x4000L);
263 case 101:
264 return jjMoveStringLiteralDfa5_0(active0, 0x400L);
265 case 104:
266 return jjMoveStringLiteralDfa5_0(active0, 0x100L);
267 case 111:
268 return jjMoveStringLiteralDfa5_0(active0, 0x8000L);
269 case 114:
270 return jjMoveStringLiteralDfa5_0(active0, 0x200L);
271 case 115:
272 return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
273 case 117:
274 return jjMoveStringLiteralDfa5_0(active0, 0x1000L);
275 default :
276 break;
277 }
278 return jjStartNfa_0(3, active0);
279 }
280 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
281 {
282 if (((active0 &= old0)) == 0L)
283 return jjStartNfa_0(3, old0);
284 try { curChar = input_stream.readChar(); }
285 catch(java.io.IOException e) {
286 jjStopStringLiteralDfa_0(4, active0);
287 return 5;
288 }
289 switch(curChar)
290 {
291 case 101:
292 if ((active0 & 0x4000L) != 0L)
293 return jjStartNfaWithStates_0(5, 14, 3);
294 return jjMoveStringLiteralDfa6_0(active0, 0x200L);
295 case 105:
296 return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
297 case 109:
298 if ((active0 & 0x800L) != 0L)
299 return jjStartNfaWithStates_0(5, 11, 3);
300 break;
301 case 111:
302 return jjMoveStringLiteralDfa6_0(active0, 0x100L);
303 case 112:
304 return jjMoveStringLiteralDfa6_0(active0, 0x400L);
305 case 114:
306 return jjMoveStringLiteralDfa6_0(active0, 0x1000L);
307 case 119:
308 return jjMoveStringLiteralDfa6_0(active0, 0x8000L);
309 default :
310 break;
311 }
312 return jjStartNfa_0(4, active0);
313 }
314 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
315 {
316 if (((active0 &= old0)) == 0L)
317 return jjStartNfa_0(4, old0);
318 try { curChar = input_stream.readChar(); }
319 catch(java.io.IOException e) {
320 jjStopStringLiteralDfa_0(5, active0);
321 return 6;
322 }
323 switch(curChar)
324 {
325 case 99:
326 return jjMoveStringLiteralDfa7_0(active0, 0x200L);
327 case 110:
328 if ((active0 & 0x1000L) != 0L)
329 return jjStartNfaWithStates_0(6, 12, 3);
330 break;
331 case 111:
332 return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
333 case 114:
334 if ((active0 & 0x100L) != 0L)
335 return jjStartNfaWithStates_0(6, 8, 3);
336 break;
337 case 115:
338 if ((active0 & 0x8000L) != 0L)
339 return jjStartNfaWithStates_0(6, 15, 3);
340 break;
341 case 116:
342 return jjMoveStringLiteralDfa7_0(active0, 0x400L);
343 default :
344 break;
345 }
346 return jjStartNfa_0(5, active0);
347 }
348 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
349 {
350 if (((active0 &= old0)) == 0L)
351 return jjStartNfa_0(5, old0);
352 try { curChar = input_stream.readChar(); }
353 catch(java.io.IOException e) {
354 jjStopStringLiteralDfa_0(6, active0);
355 return 7;
356 }
357 switch(curChar)
358 {
359 case 97:
360 return jjMoveStringLiteralDfa8_0(active0, 0x200L);
361 case 105:
362 return jjMoveStringLiteralDfa8_0(active0, 0x400L);
363 case 110:
364 if ((active0 & 0x10000L) != 0L)
365 return jjStartNfaWithStates_0(7, 16, 3);
366 break;
367 default :
368 break;
369 }
370 return jjStartNfa_0(6, active0);
371 }
372 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
373 {
374 if (((active0 &= old0)) == 0L)
375 return jjStartNfa_0(6, old0);
376 try { curChar = input_stream.readChar(); }
377 catch(java.io.IOException e) {
378 jjStopStringLiteralDfa_0(7, active0);
379 return 8;
380 }
381 switch(curChar)
382 {
383 case 111:
384 return jjMoveStringLiteralDfa9_0(active0, 0x400L);
385 case 116:
386 return jjMoveStringLiteralDfa9_0(active0, 0x200L);
387 default :
388 break;
389 }
390 return jjStartNfa_0(7, active0);
391 }
392 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
393 {
394 if (((active0 &= old0)) == 0L)
395 return jjStartNfa_0(7, old0);
396 try { curChar = input_stream.readChar(); }
397 catch(java.io.IOException e) {
398 jjStopStringLiteralDfa_0(8, active0);
399 return 9;
400 }
401 switch(curChar)
402 {
403 case 101:
404 return jjMoveStringLiteralDfa10_0(active0, 0x200L);
405 case 110:
406 if ((active0 & 0x400L) != 0L)
407 return jjStartNfaWithStates_0(9, 10, 3);
408 break;
409 default :
410 break;
411 }
412 return jjStartNfa_0(8, active0);
413 }
414 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
415 {
416 if (((active0 &= old0)) == 0L)
417 return jjStartNfa_0(8, old0);
418 try { curChar = input_stream.readChar(); }
419 catch(java.io.IOException e) {
420 jjStopStringLiteralDfa_0(9, active0);
421 return 10;
422 }
423 switch(curChar)
424 {
425 case 100:
426 if ((active0 & 0x200L) != 0L)
427 return jjStartNfaWithStates_0(10, 9, 3);
428 break;
429 default :
430 break;
431 }
432 return jjStartNfa_0(9, active0);
433 }
434 private final void jjCheckNAdd(int state)
435 {
436 if (jjrounds[state] != jjround)
437 {
438 jjstateSet[jjnewStateCnt++] = state;
439 jjrounds[state] = jjround;
440 }
441 }
442 private final void jjAddStates(int start, int end)
443 {
444 do {
445 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
446 } while (start++ != end);
447 }
448 private final void jjCheckNAddTwoStates(int state1, int state2)
449 {
450 jjCheckNAdd(state1);
451 jjCheckNAdd(state2);
452 }
453 private final void jjCheckNAddStates(int start, int end)
454 {
455 do {
456 jjCheckNAdd(jjnextStates[start]);
457 } while (start++ != end);
458 }
459 private final void jjCheckNAddStates(int start)
460 {
461 jjCheckNAdd(jjnextStates[start]);
462 jjCheckNAdd(jjnextStates[start + 1]);
463 }
464 static final long[] jjbitVec0 = {
465 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
466 };
467 static final long[] jjbitVec2 = {
468 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
469 };
470 private final int jjMoveNfa_0(int startState, int curPos)
471 {
472 int[] nextStates;
473 int startsAt = 0;
474 jjnewStateCnt = 4;
475 int i = 1;
476 jjstateSet[0] = startState;
477 int j, kind = 0x7fffffff;
478 for (;;)
479 {
480 if (++jjround == 0x7fffffff)
481 ReInitRounds();
482 if (curChar < 64)
483 {
484 long l = 1L << curChar;
485 MatchLoop: do
486 {
487 switch(jjstateSet[--i])
488 {
489 case 2:
490 if ((0xfffffffeffffd9ffL & l) != 0L)
491 {
492 if (kind > 18)
493 kind = 18;
494 jjCheckNAdd(3);
495 }
496 if (curChar == 47)
497 jjstateSet[jjnewStateCnt++] = 0;
498 break;
499 case 0:
500 if (curChar == 42)
501 jjCheckNAdd(1);
502 break;
503 case 1:
504 if (curChar != 42)
505 break;
506 if (kind > 5)
507 kind = 5;
508 jjCheckNAdd(1);
509 break;
510 case 3:
511 if ((0xfffffffeffffd9ffL & l) == 0L)
512 break;
513 if (kind > 18)
514 kind = 18;
515 jjCheckNAdd(3);
516 break;
517 default : break;
518 }
519 } while(i != startsAt);
520 }
521 else if (curChar < 128)
522 {
523 long l = 1L << (curChar & 077);
524 MatchLoop: do
525 {
526 switch(jjstateSet[--i])
527 {
528 case 2:
529 case 3:
530 kind = 18;
531 jjCheckNAdd(3);
532 break;
533 default : break;
534 }
535 } while(i != startsAt);
536 }
537 else
538 {
539 int hiByte = (int)(curChar >> 8);
540 int i1 = hiByte >> 6;
541 long l1 = 1L << (hiByte & 077);
542 int i2 = (curChar & 0xff) >> 6;
543 long l2 = 1L << (curChar & 077);
544 MatchLoop: do
545 {
546 switch(jjstateSet[--i])
547 {
548 case 2:
549 case 3:
550 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
551 break;
552 if (kind > 18)
553 kind = 18;
554 jjCheckNAdd(3);
555 break;
556 default : break;
557 }
558 } while(i != startsAt);
559 }
560 if (kind != 0x7fffffff)
561 {
562 jjmatchedKind = kind;
563 jjmatchedPos = curPos;
564 kind = 0x7fffffff;
565 }
566 ++curPos;
567 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
568 return curPos;
569 try { curChar = input_stream.readChar(); }
570 catch(java.io.IOException e) { return curPos; }
571 }
572 }
573 static final int[] jjnextStates = {
574 };
575 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
576 {
577 switch(hiByte)
578 {
579 case 0:
580 return ((jjbitVec2[i2] & l2) != 0L);
581 default :
582 if ((jjbitVec0[i1] & l1) != 0L)
583 return true;
584 return false;
585 }
586 }
587 public static final String [] jjstrLiteralImages = {
588 "", null, null, null, "\12", null, "\52\57", "\52",
589 "\100\141\165\164\150\157\162", "\100\144\145\160\162\145\143\141\164\145\144",
590 "\100\145\170\143\145\160\164\151\157\156", "\100\160\141\162\141\155", "\100\162\145\164\165\162\156",
591 "\100\163\145\145", "\100\163\151\156\143\145", "\100\164\150\162\157\167\163",
592 "\100\166\145\162\163\151\157\156", "\100\151\144", null, };
593 public static final String [] lexStateNames = {
594 "DEFAULT",
595 };
596 static final long[] jjtoToken = {
597 0x7fff1L,
598 };
599 static final long[] jjtoSkip = {
600 0xeL,
601 };
602 protected JavaCharStream input_stream;
603 private final int[] jjrounds = new int[4];
604 private final int[] jjstateSet = new int[8];
605 StringBuffer image;
606 int jjimageLen;
607 int lengthOfMatch;
608 protected char curChar;
609 public JavadocParserTokenManager(JavaCharStream stream)
610 {
611 if (JavaCharStream.staticFlag)
612 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
613 input_stream = stream;
614 }
615 public JavadocParserTokenManager(JavaCharStream stream, int lexState)
616 {
617 this(stream);
618 SwitchTo(lexState);
619 }
620 public void ReInit(JavaCharStream stream)
621 {
622 jjmatchedPos = jjnewStateCnt = 0;
623 curLexState = defaultLexState;
624 input_stream = stream;
625 ReInitRounds();
626 }
627 private final void ReInitRounds()
628 {
629 int i;
630 jjround = 0x80000001;
631 for (i = 4; i-- > 0;)
632 jjrounds[i] = 0x80000000;
633 }
634 public void ReInit(JavaCharStream stream, int lexState)
635 {
636 ReInit(stream);
637 SwitchTo(lexState);
638 }
639 public void SwitchTo(int lexState)
640 {
641 if (lexState >= 1 || lexState < 0)
642 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
643 else
644 curLexState = lexState;
645 }
646
647 protected Token jjFillToken()
648 {
649 Token t = Token.newToken(jjmatchedKind);
650 t.kind = jjmatchedKind;
651 if (jjmatchedPos < 0)
652 {
653 if (image == null)
654 t.image = "";
655 else
656 t.image = image.toString();
657 t.beginLine = t.endLine = input_stream.getBeginLine();
658 t.beginColumn = t.endColumn = input_stream.getBeginColumn();
659 }
660 else
661 {
662 String im = jjstrLiteralImages[jjmatchedKind];
663 t.image = (im == null) ? input_stream.GetImage() : im;
664 t.beginLine = input_stream.getBeginLine();
665 t.beginColumn = input_stream.getBeginColumn();
666 t.endLine = input_stream.getEndLine();
667 t.endColumn = input_stream.getEndColumn();
668 }
669 return t;
670 }
671
672 int curLexState = 0;
673 int defaultLexState = 0;
674 int jjnewStateCnt;
675 int jjround;
676 int jjmatchedPos;
677 int jjmatchedKind;
678
679 public Token getNextToken()
680 {
681 int kind;
682 Token specialToken = null;
683 Token matchedToken;
684 int curPos = 0;
685
686 EOFLoop :
687 for (;;)
688 {
689 try
690 {
691 curChar = input_stream.BeginToken();
692 }
693 catch(java.io.IOException e)
694 {
695 jjmatchedKind = 0;
696 matchedToken = jjFillToken();
697 return matchedToken;
698 }
699 image = null;
700 jjimageLen = 0;
701
702 try { input_stream.backup(0);
703 while (curChar <= 32 && (0x100002200L & (1L << curChar)) != 0L)
704 curChar = input_stream.BeginToken();
705 }
706 catch (java.io.IOException e1) { continue EOFLoop; }
707 jjmatchedKind = 18;
708 jjmatchedPos = -1;
709 curPos = 0;
710 curPos = jjMoveStringLiteralDfa0_0();
711 if (jjmatchedKind != 0x7fffffff)
712 {
713 if (jjmatchedPos + 1 < curPos)
714 input_stream.backup(curPos - jjmatchedPos - 1);
715 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
716 {
717 matchedToken = jjFillToken();
718 TokenLexicalActions(matchedToken);
719 return matchedToken;
720 }
721 else
722 {
723 continue EOFLoop;
724 }
725 }
726 int error_line = input_stream.getEndLine();
727 int error_column = input_stream.getEndColumn();
728 String error_after = null;
729 boolean EOFSeen = false;
730 try { input_stream.readChar(); input_stream.backup(1); }
731 catch (java.io.IOException e1) {
732 EOFSeen = true;
733 error_after = curPos <= 1 ? "" : input_stream.GetImage();
734 if (curChar == '\n' || curChar == '\r') {
735 error_line++;
736 error_column = 0;
737 }
738 else
739 error_column++;
740 }
741 if (!EOFSeen) {
742 input_stream.backup(1);
743 error_after = curPos <= 1 ? "" : input_stream.GetImage();
744 }
745 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
746 }
747 }
748
749 int[] jjemptyLineNo = new int[1];
750 int[] jjemptyColNo = new int[1];
751 boolean[] jjbeenHere = new boolean[1];
752 void TokenLexicalActions(Token matchedToken)
753 {
754 switch(jjmatchedKind)
755 {
756 case 0 :
757 break;
758 case 4 :
759 break;
760 case 5 :
761 break;
762 case 6 :
763 break;
764 case 7 :
765 break;
766 case 8 :
767 break;
768 case 9 :
769 break;
770 case 10 :
771 break;
772 case 11 :
773 break;
774 case 12 :
775 break;
776 case 13 :
777 break;
778 case 14 :
779 break;
780 case 15 :
781 break;
782 case 16 :
783 break;
784 case 17 :
785 break;
786 case 18 :
787 if (jjmatchedPos == -1)
788 {
789 if (jjbeenHere[0] &&
790 jjemptyLineNo[0] == input_stream.getBeginLine() &&
791 jjemptyColNo[0] == input_stream.getBeginColumn())
792 throw new TokenMgrError(("Error: Bailing out of infinite loop caused by repeated empty string matches at line " + input_stream.getBeginLine() + ", column " + input_stream.getBeginColumn() + "."), TokenMgrError.LOOP_DETECTED);
793 jjemptyLineNo[0] = input_stream.getBeginLine();
794 jjemptyColNo[0] = input_stream.getBeginColumn();
795 jjbeenHere[0] = true;
796 }
797 break;
798 default :
799 break;
800 }
801 }
802 }
803 |
Popular Tags |
Java API By Example, From Geeks To Geeks.