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