1
2 package org.exolab.castor.xml.dtd.parser;
3
4 public class DTDInitialParserTokenManager implements DTDInitialParserConstants
5 {
6 private final int jjMoveStringLiteralDfa0_0()
7 {
8 return jjMoveNfa_0(1, 0);
9 }
10 private final void jjCheckNAdd(int state)
11 {
12 if (jjrounds[state] != jjround)
13 {
14 jjstateSet[jjnewStateCnt++] = state;
15 jjrounds[state] = jjround;
16 }
17 }
18 private final void jjAddStates(int start, int end)
19 {
20 do {
21 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
22 } while (start++ != end);
23 }
24 private final void jjCheckNAddTwoStates(int state1, int state2)
25 {
26 jjCheckNAdd(state1);
27 jjCheckNAdd(state2);
28 }
29 static final long[] jjbitVec0 = {
30 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
31 };
32 static final long[] jjbitVec1 = {
33 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
34 };
35 static final long[] jjbitVec3 = {
36 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
37 };
38 static final long[] jjbitVec4 = {
39 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
40 };
41 static final long[] jjbitVec5 = {
42 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
43 };
44 static final long[] jjbitVec6 = {
45 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
46 };
47 static final long[] jjbitVec7 = {
48 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
49 };
50 static final long[] jjbitVec8 = {
51 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
52 };
53 static final long[] jjbitVec9 = {
54 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
55 };
56 static final long[] jjbitVec10 = {
57 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
58 };
59 static final long[] jjbitVec11 = {
60 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
61 };
62 static final long[] jjbitVec12 = {
63 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
64 };
65 static final long[] jjbitVec13 = {
66 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
67 };
68 static final long[] jjbitVec14 = {
69 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
70 };
71 static final long[] jjbitVec15 = {
72 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
73 };
74 static final long[] jjbitVec16 = {
75 0x0L, 0x3fffffffeffL, 0x0L, 0x0L
76 };
77 static final long[] jjbitVec17 = {
78 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
79 };
80 static final long[] jjbitVec18 = {
81 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
82 };
83 static final long[] jjbitVec19 = {
84 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
85 };
86 static final long[] jjbitVec20 = {
87 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
88 };
89 static final long[] jjbitVec21 = {
90 0x4c4000000000L, 0x0L, 0x7L, 0x0L
91 };
92 static final long[] jjbitVec22 = {
93 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
94 };
95 static final long[] jjbitVec23 = {
96 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
97 };
98 static final long[] jjbitVec24 = {
99 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
100 };
101 static final long[] jjbitVec25 = {
102 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
103 };
104 static final long[] jjbitVec26 = {
105 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
106 };
107 static final long[] jjbitVec27 = {
108 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
109 };
110 static final long[] jjbitVec28 = {
111 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
112 };
113 static final long[] jjbitVec29 = {
114 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
115 };
116 static final long[] jjbitVec30 = {
117 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
118 };
119 static final long[] jjbitVec31 = {
120 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
121 };
122 static final long[] jjbitVec32 = {
123 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
124 };
125 static final long[] jjbitVec33 = {
126 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
127 };
128 static final long[] jjbitVec34 = {
129 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
130 };
131 static final long[] jjbitVec35 = {
132 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
133 };
134 static final long[] jjbitVec36 = {
135 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
136 };
137 static final long[] jjbitVec37 = {
138 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
139 };
140 static final long[] jjbitVec38 = {
141 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
142 };
143 static final long[] jjbitVec39 = {
144 0x0L, 0x0L, 0x0L, 0x21fff0000L
145 };
146 static final long[] jjbitVec40 = {
147 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
148 };
149 private final int jjMoveNfa_0(int startState, int curPos)
150 {
151 int startsAt = 0;
152 jjnewStateCnt = 17;
153 int i = 1;
154 jjstateSet[0] = startState;
155 int kind = 0x7fffffff;
156 for (;;)
157 {
158 if (++jjround == 0x7fffffff)
159 ReInitRounds();
160 if (curChar < 64)
161 {
162 long l = 1L << curChar;
163 MatchLoop: do
164 {
165 switch(jjstateSet[--i])
166 {
167 case 1:
168 if ((0xefffffdfffffffffL & l) != 0L)
169 {
170 if (kind > 8)
171 kind = 8;
172 jjCheckNAdd(0);
173 }
174 else if ((0x1000002000000000L & l) != 0L)
175 {
176 if (kind > 8)
177 kind = 8;
178 }
179 if (curChar == 37)
180 jjstateSet[jjnewStateCnt++] = 14;
181 else if (curChar == 60)
182 jjstateSet[jjnewStateCnt++] = 11;
183 break;
184 case 0:
185 if ((0xefffffdfffffffffL & l) == 0L)
186 break;
187 if (kind > 8)
188 kind = 8;
189 jjCheckNAdd(0);
190 break;
191 case 3:
192 if ((0x100002600L & l) != 0L)
193 jjAddStates(0, 1);
194 break;
195 case 4:
196 if (curChar == 37)
197 jjCheckNAdd(5);
198 break;
199 case 5:
200 if ((0x100002600L & l) == 0L)
201 break;
202 if (kind > 9)
203 kind = 9;
204 jjCheckNAdd(5);
205 break;
206 case 11:
207 if (curChar == 33)
208 jjstateSet[jjnewStateCnt++] = 10;
209 break;
210 case 12:
211 if (curChar == 60)
212 jjstateSet[jjnewStateCnt++] = 11;
213 break;
214 case 13:
215 if (curChar == 37)
216 jjstateSet[jjnewStateCnt++] = 14;
217 break;
218 case 14:
219 if (curChar == 58)
220 jjCheckNAddTwoStates(15, 16);
221 break;
222 case 15:
223 if ((0x7ff600000000000L & l) != 0L)
224 jjCheckNAddTwoStates(15, 16);
225 break;
226 case 16:
227 if (curChar == 59 && kind > 10)
228 kind = 10;
229 break;
230 default : break;
231 }
232 } while(i != startsAt);
233 }
234 else if (curChar < 128)
235 {
236 long l = 1L << (curChar & 077);
237 MatchLoop: do
238 {
239 switch(jjstateSet[--i])
240 {
241 case 1:
242 case 0:
243 if (kind > 8)
244 kind = 8;
245 jjCheckNAdd(0);
246 break;
247 case 2:
248 if (curChar == 89)
249 jjstateSet[jjnewStateCnt++] = 3;
250 break;
251 case 6:
252 if (curChar == 84)
253 jjstateSet[jjnewStateCnt++] = 2;
254 break;
255 case 7:
256 if (curChar == 73)
257 jjstateSet[jjnewStateCnt++] = 6;
258 break;
259 case 8:
260 if (curChar == 84)
261 jjstateSet[jjnewStateCnt++] = 7;
262 break;
263 case 9:
264 if (curChar == 78)
265 jjstateSet[jjnewStateCnt++] = 8;
266 break;
267 case 10:
268 if (curChar == 69)
269 jjstateSet[jjnewStateCnt++] = 9;
270 break;
271 case 14:
272 case 15:
273 if ((0x7fffffe87fffffeL & l) != 0L)
274 jjCheckNAddTwoStates(15, 16);
275 break;
276 default : break;
277 }
278 } while(i != startsAt);
279 }
280 else
281 {
282 int i2 = (curChar & 0xff) >> 6;
283 long l2 = 1L << (curChar & 077);
284 MatchLoop: do
285 {
286 switch(jjstateSet[--i])
287 {
288 case 1:
289 case 0:
290 if ((jjbitVec0[i2] & l2) == 0L)
291 break;
292 if (kind > 8)
293 kind = 8;
294 jjCheckNAdd(0);
295 break;
296 case 14:
297 if ((jjbitVec3[i2] & l2) != 0L)
298 jjCheckNAddTwoStates(15, 16);
299 break;
300 case 15:
301 if ((jjbitVec26[i2] & l2) != 0L)
302 jjCheckNAddTwoStates(15, 16);
303 break;
304 default : break;
305 }
306 } while(i != startsAt);
307 }
308 if (kind != 0x7fffffff)
309 {
310 jjmatchedKind = kind;
311 jjmatchedPos = curPos;
312 kind = 0x7fffffff;
313 }
314 ++curPos;
315 if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt)))
316 return curPos;
317 try { curChar = input_stream.readChar(); }
318 catch(java.io.IOException e) { return curPos; }
319 }
320 }
321 private final int jjStopAtPos(int pos, int kind)
322 {
323 jjmatchedKind = kind;
324 jjmatchedPos = pos;
325 return pos + 1;
326 }
327 private final int jjMoveStringLiteralDfa0_2()
328 {
329 switch(curChar)
330 {
331 case 34:
332 return jjStopAtPos(0, 18);
333 default :
334 return jjMoveNfa_2(1, 0);
335 }
336 }
337 private final int jjMoveNfa_2(int startState, int curPos)
338 {
339 int startsAt = 0;
340 jjnewStateCnt = 5;
341 int i = 1;
342 jjstateSet[0] = startState;
343 int kind = 0x7fffffff;
344 for (;;)
345 {
346 if (++jjround == 0x7fffffff)
347 ReInitRounds();
348 if (curChar < 64)
349 {
350 long l = 1L << curChar;
351 MatchLoop: do
352 {
353 switch(jjstateSet[--i])
354 {
355 case 1:
356 if ((0xffffffdbffffffffL & l) != 0L)
357 {
358 if (kind > 16)
359 kind = 16;
360 jjCheckNAdd(0);
361 }
362 else if (curChar == 37)
363 jjstateSet[jjnewStateCnt++] = 2;
364 break;
365 case 0:
366 if ((0xffffffdbffffffffL & l) == 0L)
367 break;
368 if (kind > 16)
369 kind = 16;
370 jjCheckNAdd(0);
371 break;
372 case 2:
373 if (curChar == 58)
374 jjCheckNAddTwoStates(3, 4);
375 break;
376 case 3:
377 if ((0x7ff600000000000L & l) != 0L)
378 jjCheckNAddTwoStates(3, 4);
379 break;
380 case 4:
381 if (curChar == 59 && kind > 17)
382 kind = 17;
383 break;
384 default : break;
385 }
386 } while(i != startsAt);
387 }
388 else if (curChar < 128)
389 {
390 long l = 1L << (curChar & 077);
391 MatchLoop: do
392 {
393 switch(jjstateSet[--i])
394 {
395 case 1:
396 case 0:
397 if (kind > 16)
398 kind = 16;
399 jjCheckNAdd(0);
400 break;
401 case 2:
402 case 3:
403 if ((0x7fffffe87fffffeL & l) != 0L)
404 jjCheckNAddTwoStates(3, 4);
405 break;
406 default : break;
407 }
408 } while(i != startsAt);
409 }
410 else
411 {
412 int i2 = (curChar & 0xff) >> 6;
413 long l2 = 1L << (curChar & 077);
414 MatchLoop: do
415 {
416 switch(jjstateSet[--i])
417 {
418 case 1:
419 case 0:
420 if ((jjbitVec0[i2] & l2) == 0L)
421 break;
422 if (kind > 16)
423 kind = 16;
424 jjCheckNAdd(0);
425 break;
426 case 2:
427 if ((jjbitVec3[i2] & l2) != 0L)
428 jjCheckNAddTwoStates(3, 4);
429 break;
430 case 3:
431 if ((jjbitVec26[i2] & l2) != 0L)
432 jjCheckNAddTwoStates(3, 4);
433 break;
434 default : break;
435 }
436 } while(i != startsAt);
437 }
438 if (kind != 0x7fffffff)
439 {
440 jjmatchedKind = kind;
441 jjmatchedPos = curPos;
442 kind = 0x7fffffff;
443 }
444 ++curPos;
445 if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
446 return curPos;
447 try { curChar = input_stream.readChar(); }
448 catch(java.io.IOException e) { return curPos; }
449 }
450 }
451 private final int jjMoveStringLiteralDfa0_1()
452 {
453 switch(curChar)
454 {
455 case 34:
456 return jjStopAtPos(0, 13);
457 case 39:
458 return jjStopAtPos(0, 14);
459 case 62:
460 return jjStopAtPos(0, 15);
461 default :
462 return jjMoveNfa_1(0, 0);
463 }
464 }
465 private final int jjMoveNfa_1(int startState, int curPos)
466 {
467 int startsAt = 0;
468 jjnewStateCnt = 3;
469 int i = 1;
470 jjstateSet[0] = startState;
471 int kind = 0x7fffffff;
472 for (;;)
473 {
474 if (++jjround == 0x7fffffff)
475 ReInitRounds();
476 if (curChar < 64)
477 {
478 long l = 1L << curChar;
479 MatchLoop: do
480 {
481 switch(jjstateSet[--i])
482 {
483 case 0:
484 if ((0x100002600L & l) != 0L)
485 {
486 if (kind > 12)
487 kind = 12;
488 jjCheckNAdd(2);
489 }
490 else if (curChar == 58)
491 {
492 if (kind > 11)
493 kind = 11;
494 jjCheckNAdd(1);
495 }
496 break;
497 case 1:
498 if ((0x7ff600000000000L & l) == 0L)
499 break;
500 if (kind > 11)
501 kind = 11;
502 jjCheckNAdd(1);
503 break;
504 case 2:
505 if ((0x100002600L & l) == 0L)
506 break;
507 kind = 12;
508 jjCheckNAdd(2);
509 break;
510 default : break;
511 }
512 } while(i != startsAt);
513 }
514 else if (curChar < 128)
515 {
516 long l = 1L << (curChar & 077);
517 MatchLoop: do
518 {
519 switch(jjstateSet[--i])
520 {
521 case 0:
522 case 1:
523 if ((0x7fffffe87fffffeL & l) == 0L)
524 break;
525 if (kind > 11)
526 kind = 11;
527 jjCheckNAdd(1);
528 break;
529 default : break;
530 }
531 } while(i != startsAt);
532 }
533 else
534 {
535 int i2 = (curChar & 0xff) >> 6;
536 long l2 = 1L << (curChar & 077);
537 MatchLoop: do
538 {
539 switch(jjstateSet[--i])
540 {
541 case 0:
542 if ((jjbitVec3[i2] & l2) == 0L)
543 break;
544 if (kind > 11)
545 kind = 11;
546 jjCheckNAdd(1);
547 break;
548 case 1:
549 if ((jjbitVec26[i2] & l2) == 0L)
550 break;
551 if (kind > 11)
552 kind = 11;
553 jjCheckNAdd(1);
554 break;
555 default : break;
556 }
557 } while(i != startsAt);
558 }
559 if (kind != 0x7fffffff)
560 {
561 jjmatchedKind = kind;
562 jjmatchedPos = curPos;
563 kind = 0x7fffffff;
564 }
565 ++curPos;
566 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
567 return curPos;
568 try { curChar = input_stream.readChar(); }
569 catch(java.io.IOException e) { return curPos; }
570 }
571 }
572 private final int jjMoveStringLiteralDfa0_3()
573 {
574 switch(curChar)
575 {
576 case 39:
577 return jjStopAtPos(0, 21);
578 default :
579 return jjMoveNfa_3(1, 0);
580 }
581 }
582 private final int jjMoveNfa_3(int startState, int curPos)
583 {
584 int startsAt = 0;
585 jjnewStateCnt = 5;
586 int i = 1;
587 jjstateSet[0] = startState;
588 int kind = 0x7fffffff;
589 for (;;)
590 {
591 if (++jjround == 0x7fffffff)
592 ReInitRounds();
593 if (curChar < 64)
594 {
595 long l = 1L << curChar;
596 MatchLoop: do
597 {
598 switch(jjstateSet[--i])
599 {
600 case 1:
601 if ((0xffffff5fffffffffL & l) != 0L)
602 {
603 if (kind > 19)
604 kind = 19;
605 jjCheckNAdd(0);
606 }
607 else if (curChar == 37)
608 jjstateSet[jjnewStateCnt++] = 2;
609 break;
610 case 0:
611 if ((0xffffff5fffffffffL & l) == 0L)
612 break;
613 if (kind > 19)
614 kind = 19;
615 jjCheckNAdd(0);
616 break;
617 case 2:
618 if (curChar == 58)
619 jjCheckNAddTwoStates(3, 4);
620 break;
621 case 3:
622 if ((0x7ff600000000000L & l) != 0L)
623 jjCheckNAddTwoStates(3, 4);
624 break;
625 case 4:
626 if (curChar == 59 && kind > 20)
627 kind = 20;
628 break;
629 default : break;
630 }
631 } while(i != startsAt);
632 }
633 else if (curChar < 128)
634 {
635 long l = 1L << (curChar & 077);
636 MatchLoop: do
637 {
638 switch(jjstateSet[--i])
639 {
640 case 1:
641 case 0:
642 if (kind > 19)
643 kind = 19;
644 jjCheckNAdd(0);
645 break;
646 case 2:
647 case 3:
648 if ((0x7fffffe87fffffeL & l) != 0L)
649 jjCheckNAddTwoStates(3, 4);
650 break;
651 default : break;
652 }
653 } while(i != startsAt);
654 }
655 else
656 {
657 int i2 = (curChar & 0xff) >> 6;
658 long l2 = 1L << (curChar & 077);
659 MatchLoop: do
660 {
661 switch(jjstateSet[--i])
662 {
663 case 1:
664 case 0:
665 if ((jjbitVec0[i2] & l2) == 0L)
666 break;
667 if (kind > 19)
668 kind = 19;
669 jjCheckNAdd(0);
670 break;
671 case 2:
672 if ((jjbitVec3[i2] & l2) != 0L)
673 jjCheckNAddTwoStates(3, 4);
674 break;
675 case 3:
676 if ((jjbitVec26[i2] & l2) != 0L)
677 jjCheckNAddTwoStates(3, 4);
678 break;
679 default : break;
680 }
681 } while(i != startsAt);
682 }
683 if (kind != 0x7fffffff)
684 {
685 jjmatchedKind = kind;
686 jjmatchedPos = curPos;
687 kind = 0x7fffffff;
688 }
689 ++curPos;
690 if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
691 return curPos;
692 try { curChar = input_stream.readChar(); }
693 catch(java.io.IOException e) { return curPos; }
694 }
695 }
696 static final int[] jjnextStates = {
697 3, 4,
698 };
699 public static final String[] jjstrLiteralImages = {
700 "", null, null, null, null, null, null, null, null, null, null, null, null,
701 "\42", "\47", "\76", null, null, "\42", null, null, "\47", };
702 public static final String[] lexStateNames = {
703 "DEFAULT",
704 "WithinPEdecl",
705 "WithinEntityValueDQ",
706 "WithinEntityValueSQ",
707 };
708 public static final int[] jjnewLexState = {
709 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 2, 3, 0, -1, -1, 1, -1, -1, 1,
710 };
711 private CharStream input_stream;
712 private final int[] jjrounds = new int[17];
713 private final int[] jjstateSet = new int[34];
714 protected char curChar;
715 public DTDInitialParserTokenManager(CharStream stream)
716 {
717 input_stream = stream;
718 }
719 public DTDInitialParserTokenManager(CharStream stream, int lexState)
720 {
721 this(stream);
722 SwitchTo(lexState);
723 }
724 public void ReInit(CharStream stream)
725 {
726 jjmatchedPos = jjnewStateCnt = 0;
727 curLexState = defaultLexState;
728 input_stream = stream;
729 ReInitRounds();
730 }
731 private final void ReInitRounds()
732 {
733 int i;
734 jjround = 0x80000001;
735 for (i = 17; i-- > 0;)
736 jjrounds[i] = 0x80000000;
737 }
738
739 public void ReInit(CharStream stream, int lexState) {
740 ReInit(stream);
741 SwitchTo(lexState);
742 }
743
744 public void SwitchTo(int lexState) {
745 if (lexState >= 4 || lexState < 0) {
746 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
747 }
748 curLexState = lexState;
749 }
750
751 private final Token jjFillToken() {
752 Token t = Token.newToken(jjmatchedKind);
753 t.kind = jjmatchedKind;
754 String im = jjstrLiteralImages[jjmatchedKind];
755 t.image = (im == null) ? input_stream.GetImage() : im;
756 t.beginLine = input_stream.getBeginLine();
757 t.beginColumn = input_stream.getBeginColumn();
758 t.endLine = input_stream.getEndLine();
759 t.endColumn = input_stream.getEndColumn();
760 return t;
761 }
762
763 int curLexState = 0;
764 int defaultLexState = 0;
765 int jjnewStateCnt;
766 int jjround;
767 int jjmatchedPos;
768 int jjmatchedKind;
769
770 public final Token getNextToken() {
771 Token matchedToken;
772 int curPos = 0;
773
774 EOFLoop :
775 for (;;)
776 {
777 try
778 {
779 curChar = input_stream.BeginToken();
780 }
781 catch(java.io.IOException e)
782 {
783 jjmatchedKind = 0;
784 matchedToken = jjFillToken();
785 return matchedToken;
786 }
787
788 switch(curLexState)
789 {
790 case 0:
791 jjmatchedKind = 0x7fffffff;
792 jjmatchedPos = 0;
793 curPos = jjMoveStringLiteralDfa0_0();
794 break;
795 case 1:
796 jjmatchedKind = 0x7fffffff;
797 jjmatchedPos = 0;
798 curPos = jjMoveStringLiteralDfa0_1();
799 break;
800 case 2:
801 jjmatchedKind = 0x7fffffff;
802 jjmatchedPos = 0;
803 curPos = jjMoveStringLiteralDfa0_2();
804 break;
805 case 3:
806 jjmatchedKind = 0x7fffffff;
807 jjmatchedPos = 0;
808 curPos = jjMoveStringLiteralDfa0_3();
809 break;
810 }
811 if (jjmatchedKind != 0x7fffffff)
812 {
813 if (jjmatchedPos + 1 < curPos)
814 input_stream.backup(curPos - jjmatchedPos - 1);
815 matchedToken = jjFillToken();
816 if (jjnewLexState[jjmatchedKind] != -1)
817 curLexState = jjnewLexState[jjmatchedKind];
818 return matchedToken;
819 }
820 int error_line = input_stream.getEndLine();
821 int error_column = input_stream.getEndColumn();
822 String error_after = null;
823 boolean EOFSeen = false;
824 try { input_stream.readChar(); input_stream.backup(1); }
825 catch (java.io.IOException e1) {
826 EOFSeen = true;
827 error_after = curPos <= 1 ? "" : input_stream.GetImage();
828 if (curChar == '\n' || curChar == '\r') {
829 error_line++;
830 error_column = 0;
831 }
832 else
833 error_column++;
834 }
835 if (!EOFSeen) {
836 input_stream.backup(1);
837 error_after = curPos <= 1 ? "" : input_stream.GetImage();
838 }
839 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
840 }
841 }
842
843 }