|
1
2 package com.jsptags.navigation.pager.parser;
3 import java.util.Hashtable  ;
4 import java.io.StringReader ;
5
6 public class TagExportParserTokenManager implements TagExportParserConstants
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 default :
15 return -1;
16 }
17 }
18 private final int jjStartNfa_0(int pos, long active0)
19 {
20 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
21 }
22 private final int jjStopAtPos(int pos, int kind)
23 {
24 jjmatchedKind = kind;
25 jjmatchedPos = pos;
26 return pos + 1;
27 }
28 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
29 {
30 jjmatchedKind = kind;
31 jjmatchedPos = pos;
32 try { curChar = input_stream.readChar(); }
33 catch(java.io.IOException e) { return pos + 1; }
34 return jjMoveNfa_0(state, pos + 1);
35 }
36 private final int jjMoveStringLiteralDfa0_0()
37 {
38 switch(curChar)
39 {
40 case 44:
41 return jjStopAtPos(0, 7);
42 case 59:
43 return jjStopAtPos(0, 8);
44 case 61:
45 return jjStopAtPos(0, 6);
46 default :
47 return jjMoveNfa_0(0, 0);
48 }
49 }
50 private final void jjCheckNAdd(int state)
51 {
52 if (jjrounds[state] != jjround)
53 {
54 jjstateSet[jjnewStateCnt++] = state;
55 jjrounds[state] = jjround;
56 }
57 }
58 private final void jjAddStates(int start, int end)
59 {
60 do {
61 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
62 } while (start++ != end);
63 }
64 private final void jjCheckNAddTwoStates(int state1, int state2)
65 {
66 jjCheckNAdd(state1);
67 jjCheckNAdd(state2);
68 }
69 private final void jjCheckNAddStates(int start, int end)
70 {
71 do {
72 jjCheckNAdd(jjnextStates[start]);
73 } while (start++ != end);
74 }
75 private final void jjCheckNAddStates(int start)
76 {
77 jjCheckNAdd(jjnextStates[start]);
78 jjCheckNAdd(jjnextStates[start + 1]);
79 }
80 static final long[] jjbitVec0 = {
81 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
82 };
83 static final long[] jjbitVec2 = {
84 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
85 };
86 static final long[] jjbitVec3 = {
87 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
88 };
89 static final long[] jjbitVec4 = {
90 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
91 };
92 static final long[] jjbitVec5 = {
93 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
94 };
95 static final long[] jjbitVec6 = {
96 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
97 };
98 private final int jjMoveNfa_0(int startState, int curPos)
99 {
100 int[] nextStates;
101 int startsAt = 0;
102 jjnewStateCnt = 2;
103 int i = 1;
104 jjstateSet[0] = startState;
105 int j, kind = 0x7fffffff;
106 for (;;)
107 {
108 if (++jjround == 0x7fffffff)
109 ReInitRounds();
110 if (curChar < 64)
111 {
112 long l = 1L << curChar;
113 MatchLoop: do
114 {
115 switch(jjstateSet[--i])
116 {
117 case 0:
118 if (curChar != 36)
119 break;
120 if (kind > 27)
121 kind = 27;
122 jjCheckNAdd(1);
123 break;
124 case 1:
125 if ((0x3ff001000000000L & l) == 0L)
126 break;
127 if (kind > 27)
128 kind = 27;
129 jjCheckNAdd(1);
130 break;
131 default : break;
132 }
133 } while(i != startsAt);
134 }
135 else if (curChar < 128)
136 {
137 long l = 1L << (curChar & 077);
138 MatchLoop: do
139 {
140 switch(jjstateSet[--i])
141 {
142 case 0:
143 case 1:
144 if ((0x7fffffe87fffffeL & l) == 0L)
145 break;
146 if (kind > 27)
147 kind = 27;
148 jjCheckNAdd(1);
149 break;
150 default : break;
151 }
152 } while(i != startsAt);
153 }
154 else
155 {
156 int hiByte = (int)(curChar >> 8);
157 int i1 = hiByte >> 6;
158 long l1 = 1L << (hiByte & 077);
159 int i2 = (curChar & 0xff) >> 6;
160 long l2 = 1L << (curChar & 077);
161 MatchLoop: do
162 {
163 switch(jjstateSet[--i])
164 {
165 case 0:
166 case 1:
167 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
168 break;
169 if (kind > 27)
170 kind = 27;
171 jjCheckNAdd(1);
172 break;
173 default : break;
174 }
175 } while(i != startsAt);
176 }
177 if (kind != 0x7fffffff)
178 {
179 jjmatchedKind = kind;
180 jjmatchedPos = curPos;
181 kind = 0x7fffffff;
182 }
183 ++curPos;
184 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
185 return curPos;
186 try { curChar = input_stream.readChar(); }
187 catch(java.io.IOException e) { return curPos; }
188 }
189 }
190 private final int jjStopStringLiteralDfa_2(int pos, long active0)
191 {
192 switch (pos)
193 {
194 case 0:
195 if ((active0 & 0x3c000L) != 0L)
196 {
197 jjmatchedKind = 27;
198 return 1;
199 }
200 return -1;
201 case 1:
202 if ((active0 & 0x3c000L) != 0L)
203 {
204 jjmatchedKind = 27;
205 jjmatchedPos = 1;
206 return 1;
207 }
208 return -1;
209 case 2:
210 if ((active0 & 0x3c000L) != 0L)
211 {
212 jjmatchedKind = 27;
213 jjmatchedPos = 2;
214 return 1;
215 }
216 return -1;
217 case 3:
218 if ((active0 & 0x3c000L) != 0L)
219 {
220 jjmatchedKind = 27;
221 jjmatchedPos = 3;
222 return 1;
223 }
224 return -1;
225 case 4:
226 if ((active0 & 0x28000L) != 0L)
227 return 1;
228 if ((active0 & 0x14000L) != 0L)
229 {
230 jjmatchedKind = 27;
231 jjmatchedPos = 4;
232 return 1;
233 }
234 return -1;
235 case 5:
236 if ((active0 & 0x14000L) != 0L)
237 {
238 jjmatchedKind = 27;
239 jjmatchedPos = 5;
240 return 1;
241 }
242 return -1;
243 case 6:
244 if ((active0 & 0x14000L) != 0L)
245 {
246 jjmatchedKind = 27;
247 jjmatchedPos = 6;
248 return 1;
249 }
250 return -1;
251 case 7:
252 if ((active0 & 0x14000L) != 0L)
253 {
254 jjmatchedKind = 27;
255 jjmatchedPos = 7;
256 return 1;
257 }
258 return -1;
259 default :
260 return -1;
261 }
262 }
263 private final int jjStartNfa_2(int pos, long active0)
264 {
265 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
266 }
267 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
268 {
269 jjmatchedKind = kind;
270 jjmatchedPos = pos;
271 try { curChar = input_stream.readChar(); }
272 catch(java.io.IOException e) { return pos + 1; }
273 return jjMoveNfa_2(state, pos + 1);
274 }
275 private final int jjMoveStringLiteralDfa0_2()
276 {
277 switch(curChar)
278 {
279 case 44:
280 return jjStopAtPos(0, 7);
281 case 59:
282 return jjStopAtPos(0, 8);
283 case 61:
284 return jjStopAtPos(0, 6);
285 case 105:
286 return jjMoveStringLiteralDfa1_2(0xc000L);
287 case 112:
288 return jjMoveStringLiteralDfa1_2(0x30000L);
289 default :
290 return jjMoveNfa_2(0, 0);
291 }
292 }
293 private final int jjMoveStringLiteralDfa1_2(long active0)
294 {
295 try { curChar = input_stream.readChar(); }
296 catch(java.io.IOException e) {
297 jjStopStringLiteralDfa_2(0, active0);
298 return 1;
299 }
300 switch(curChar)
301 {
302 case 97:
303 return jjMoveStringLiteralDfa2_2(active0, 0x30000L);
304 case 116:
305 return jjMoveStringLiteralDfa2_2(active0, 0xc000L);
306 default :
307 break;
308 }
309 return jjStartNfa_2(0, active0);
310 }
311 private final int jjMoveStringLiteralDfa2_2(long old0, long active0)
312 {
313 if (((active0 &= old0)) == 0L)
314 return jjStartNfa_2(0, old0);
315 try { curChar = input_stream.readChar(); }
316 catch(java.io.IOException e) {
317 jjStopStringLiteralDfa_2(1, active0);
318 return 2;
319 }
320 switch(curChar)
321 {
322 case 101:
323 return jjMoveStringLiteralDfa3_2(active0, 0xc000L);
324 case 103:
325 return jjMoveStringLiteralDfa3_2(active0, 0x30000L);
326 default :
327 break;
328 }
329 return jjStartNfa_2(1, active0);
330 }
331 private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
332 {
333 if (((active0 &= old0)) == 0L)
334 return jjStartNfa_2(1, old0);
335 try { curChar = input_stream.readChar(); }
336 catch(java.io.IOException e) {
337 jjStopStringLiteralDfa_2(2, active0);
338 return 3;
339 }
340 switch(curChar)
341 {
342 case 101:
343 return jjMoveStringLiteralDfa4_2(active0, 0x30000L);
344 case 109:
345 return jjMoveStringLiteralDfa4_2(active0, 0xc000L);
346 default :
347 break;
348 }
349 return jjStartNfa_2(2, active0);
350 }
351 private final int jjMoveStringLiteralDfa4_2(long old0, long active0)
352 {
353 if (((active0 &= old0)) == 0L)
354 return jjStartNfa_2(2, old0);
355 try { curChar = input_stream.readChar(); }
356 catch(java.io.IOException e) {
357 jjStopStringLiteralDfa_2(3, active0);
358 return 4;
359 }
360 switch(curChar)
361 {
362 case 67:
363 return jjMoveStringLiteralDfa5_2(active0, 0x14000L);
364 case 115:
365 if ((active0 & 0x8000L) != 0L)
366 return jjStartNfaWithStates_2(4, 15, 1);
367 else if ((active0 & 0x20000L) != 0L)
368 return jjStartNfaWithStates_2(4, 17, 1);
369 break;
370 default :
371 break;
372 }
373 return jjStartNfa_2(3, active0);
374 }
375 private final int jjMoveStringLiteralDfa5_2(long old0, long active0)
376 {
377 if (((active0 &= old0)) == 0L)
378 return jjStartNfa_2(3, old0);
379 try { curChar = input_stream.readChar(); }
380 catch(java.io.IOException e) {
381 jjStopStringLiteralDfa_2(4, active0);
382 return 5;
383 }
384 switch(curChar)
385 {
386 case 111:
387 return jjMoveStringLiteralDfa6_2(active0, 0x14000L);
388 default :
389 break;
390 }
391 return jjStartNfa_2(4, active0);
392 }
393 private final int jjMoveStringLiteralDfa6_2(long old0, long active0)
394 {
395 if (((active0 &= old0)) == 0L)
396 return jjStartNfa_2(4, old0);
397 try { curChar = input_stream.readChar(); }
398 catch(java.io.IOException e) {
399 jjStopStringLiteralDfa_2(5, active0);
400 return 6;
401 }
402 switch(curChar)
403 {
404 case 117:
405 return jjMoveStringLiteralDfa7_2(active0, 0x14000L);
406 default :
407 break;
408 }
409 return jjStartNfa_2(5, active0);
410 }
411 private final int jjMoveStringLiteralDfa7_2(long old0, long active0)
412 {
413 if (((active0 &= old0)) == 0L)
414 return jjStartNfa_2(5, old0);
415 try { curChar = input_stream.readChar(); }
416 catch(java.io.IOException e) {
417 jjStopStringLiteralDfa_2(6, active0);
418 return 7;
419 }
420 switch(curChar)
421 {
422 case 110:
423 return jjMoveStringLiteralDfa8_2(active0, 0x14000L);
424 default :
425 break;
426 }
427 return jjStartNfa_2(6, active0);
428 }
429 private final int jjMoveStringLiteralDfa8_2(long old0, long active0)
430 {
431 if (((active0 &= old0)) == 0L)
432 return jjStartNfa_2(6, old0);
433 try { curChar = input_stream.readChar(); }
434 catch(java.io.IOException e) {
435 jjStopStringLiteralDfa_2(7, active0);
436 return 8;
437 }
438 switch(curChar)
439 {
440 case 116:
441 if ((active0 & 0x4000L) != 0L)
442 return jjStartNfaWithStates_2(8, 14, 1);
443 else if ((active0 & 0x10000L) != 0L)
444 return jjStartNfaWithStates_2(8, 16, 1);
445 break;
446 default :
447 break;
448 }
449 return jjStartNfa_2(7, active0);
450 }
451 private final int jjMoveNfa_2(int startState, int curPos)
452 {
453 int[] nextStates;
454 int startsAt = 0;
455 jjnewStateCnt = 2;
456 int i = 1;
457 jjstateSet[0] = startState;
458 int j, kind = 0x7fffffff;
459 for (;;)
460 {
461 if (++jjround == 0x7fffffff)
462 ReInitRounds();
463 if (curChar < 64)
464 {
465 long l = 1L << curChar;
466 MatchLoop: do
467 {
468 switch(jjstateSet[--i])
469 {
470 case 0:
471 if (curChar != 36)
472 break;
473 if (kind > 27)
474 kind = 27;
475 jjCheckNAdd(1);
476 break;
477 case 1:
478 if ((0x3ff001000000000L & l) == 0L)
479 break;
480 if (kind > 27)
481 kind = 27;
482 jjCheckNAdd(1);
483 break;
484 default : break;
485 }
486 } while(i != startsAt);
487 }
488 else if (curChar < 128)
489 {
490 long l = 1L << (curChar & 077);
491 MatchLoop: do
492 {
493 switch(jjstateSet[--i])
494 {
495 case 0:
496 case 1:
497 if ((0x7fffffe87fffffeL & l) == 0L)
498 break;
499 if (kind > 27)
500 kind = 27;
501 jjCheckNAdd(1);
502 break;
503 default : break;
504 }
505 } while(i != startsAt);
506 }
507 else
508 {
509 int hiByte = (int)(curChar >> 8);
510 int i1 = hiByte >> 6;
511 long l1 = 1L << (hiByte & 077);
512 int i2 = (curChar & 0xff) >> 6;
513 long l2 = 1L << (curChar & 077);
514 MatchLoop: do
515 {
516 switch(jjstateSet[--i])
517 {
518 case 0:
519 case 1:
520 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
521 break;
522 if (kind > 27)
523 kind = 27;
524 jjCheckNAdd(1);
525 break;
526 default : break;
527 }
528 } while(i != startsAt);
529 }
530 if (kind != 0x7fffffff)
531 {
532 jjmatchedKind = kind;
533 jjmatchedPos = curPos;
534 kind = 0x7fffffff;
535 }
536 ++curPos;
537 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
538 return curPos;
539 try { curChar = input_stream.readChar(); }
540 catch(java.io.IOException e) { return curPos; }
541 }
542 }
543 private final int jjStopStringLiteralDfa_3(int pos, long active0)
544 {
545 switch (pos)
546 {
547 case 0:
548 if ((active0 & 0x7fc0000L) != 0L)
549 {
550 jjmatchedKind = 27;
551 return 1;
552 }
553 return -1;
554 case 1:
555 if ((active0 & 0x7fc0000L) != 0L)
556 {
557 jjmatchedKind = 27;
558 jjmatchedPos = 1;
559 return 1;
560 }
561 return -1;
562 case 2:
563 if ((active0 & 0x4000000L) != 0L)
564 return 1;
565 if ((active0 & 0x3fc0000L) != 0L)
566 {
567 jjmatchedKind = 27;
568 jjmatchedPos = 2;
569 return 1;
570 }
571 return -1;
572 case 3:
573 if ((active0 & 0x3b00000L) != 0L)
574 return 1;
575 if ((active0 & 0x4c0000L) != 0L)
576 {
577 if (jjmatchedPos != 3)
578 {
579 jjmatchedKind = 27;
580 jjmatchedPos = 3;
581 }
582 return 1;
583 }
584 return -1;
585 case 4:
586 if ((active0 & 0xc0000L) != 0L)
587 return 1;
588 if ((active0 & 0x3600000L) != 0L)
589 {
590 if (jjmatchedPos != 4)
591 {
592 jjmatchedKind = 27;
593 jjmatchedPos = 4;
594 }
595 return 1;
596 }
597 return -1;
598 case 5:
599 if ((active0 & 0x400000L) != 0L)
600 return 1;
601 if ((active0 & 0x3280000L) != 0L)
602 {
603 jjmatchedKind = 27;
604 jjmatchedPos = 5;
605 return 1;
606 }
607 return -1;
608 case 6:
609 if ((active0 & 0x2000000L) != 0L)
610 return 1;
611 if ((active0 & 0x1280000L) != 0L)
612 {
613 jjmatchedKind = 27;
614 jjmatchedPos = 6;
615 return 1;
616 }
617 return -1;
618 case 7:
619 if ((active0 & 0x200000L) != 0L)
620 return 1;
621 if ((active0 & 0x1080000L) != 0L)
622 {
623 jjmatchedKind = 27;
624 jjmatchedPos = 7;
625 return 1;
626 }
627 return -1;
628 case 8:
629 if ((active0 & 0x1000000L) != 0L)
630 {
631 jjmatchedKind = 27;
632 jjmatchedPos = 8;
633 return 1;
634 }
635 if ((active0 & 0x80000L) != 0L)
636 return 1;
637 return -1;
638 default :
639 return -1;
640 }
641 }
642 private final int jjStartNfa_3(int pos, long active0)
643 {
644 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
645 }
646 private final int jjStartNfaWithStates_3(int pos, int kind, int state)
647 {
648 jjmatchedKind = kind;
649 jjmatchedPos = pos;
650 try { curChar = input_stream.readChar(); }
651 catch(java.io.IOException e) { return pos + 1; }
652 return jjMoveNfa_3(state, pos + 1);
653 }
654 private final int jjMoveStringLiteralDfa0_3()
655 {
656 switch(curChar)
657 {
658 case 44:
659 return jjStopAtPos(0, 7);
660 case 59:
661 return jjStopAtPos(0, 8);
662 case 61:
663 return jjStopAtPos(0, 6);
664 case 102:
665 return jjMoveStringLiteralDfa1_3(0xc0000L);
666 case 108:
667 return jjMoveStringLiteralDfa1_3(0x300000L);
668 case 110:
669 return jjMoveStringLiteralDfa1_3(0x400000L);
670 case 112:
671 return jjMoveStringLiteralDfa1_3(0x3800000L);
672 case 117:
673 return jjMoveStringLiteralDfa1_3(0x4000000L);
674 default :
675 return jjMoveNfa_3(0, 0);
676 }
677 }
678 private final int jjMoveStringLiteralDfa1_3(long active0)
679 {
680 try { curChar = input_stream.readChar(); }
681 catch(java.io.IOException e) {
682 jjStopStringLiteralDfa_3(0, active0);
683 return 1;
684 }
685 switch(curChar)
686 {
687 case 97:
688 return jjMoveStringLiteralDfa2_3(active0, 0x3b00000L);
689 case 105:
690 return jjMoveStringLiteralDfa2_3(active0, 0xc0000L);
691 case 114:
692 return jjMoveStringLiteralDfa2_3(active0, 0x4000000L);
693 case 117:
694 return jjMoveStringLiteralDfa2_3(active0, 0x400000L);
695 default :
696 break;
697 }
698 return jjStartNfa_3(0, active0);
699 }
700 private final int jjMoveStringLiteralDfa2_3(long old0, long active0)
701 {
702 if (((active0 &= old0)) == 0L)
703 return jjStartNfa_3(0, old0);
704 try { curChar = input_stream.readChar(); }
705 catch(java.io.IOException e) {
706 jjStopStringLiteralDfa_3(1, active0);
707 return 2;
708 }
709 switch(curChar)
710 {
711 case 103:
712 return jjMoveStringLiteralDfa3_3(active0, 0x3800000L);
713 case 108:
714 if ((active0 & 0x4000000L) != 0L)
715 return jjStartNfaWithStates_3(2, 26, 1);
716 break;
717 case 109:
718 return jjMoveStringLiteralDfa3_3(active0, 0x400000L);
719 case 114:
720 return jjMoveStringLiteralDfa3_3(active0, 0xc0000L);
721 case 115:
722 return jjMoveStringLiteralDfa3_3(active0, 0x300000L);
723 default :
724 break;
725 }
726 return jjStartNfa_3(1, active0);
727 }
728 private final int jjMoveStringLiteralDfa3_3(long old0, long active0)
729 {
730 if (((active0 &= old0)) == 0L)
731 return jjStartNfa_3(1, old0);
732 try { curChar = input_stream.readChar(); }
733 catch(java.io.IOException e) {
734 jjStopStringLiteralDfa_3(2, active0);
735 return 3;
736 }
737 switch(curChar)
738 {
739 case 98:
740 return jjMoveStringLiteralDfa4_3(active0, 0x400000L);
741 case 101:
742 if ((active0 & 0x800000L) != 0L)
743 {
744 jjmatchedKind = 23;
745 jjmatchedPos = 3;
746 }
747 return jjMoveStringLiteralDfa4_3(active0, 0x3000000L);
748 case 115:
749 return jjMoveStringLiteralDfa4_3(active0, 0xc0000L);
750 case 116:
751 if ((active0 & 0x100000L) != 0L)
752 {
753 jjmatchedKind = 20;
754 jjmatchedPos = 3;
755 }
756 return jjMoveStringLiteralDfa4_3(active0, 0x200000L);
757 default :
758 break;
759 }
760 return jjStartNfa_3(2, active0);
761 }
762 private final int jjMoveStringLiteralDfa4_3(long old0, long active0)
763 {
764 if (((active0 &= old0)) == 0L)
765 return jjStartNfa_3(2, old0);
766 try { curChar = input_stream.readChar(); }
767 catch(java.io.IOException e) {
768 jjStopStringLiteralDfa_3(3, active0);
769 return 4;
770 }
771 switch(curChar)
772 {
773 case 73:
774 return jjMoveStringLiteralDfa5_3(active0, 0x200000L);
775 case 78:
776 return jjMoveStringLiteralDfa5_3(active0, 0x1000000L);
777 case 85:
778 return jjMoveStringLiteralDfa5_3(active0, 0x2000000L);
779 case 101:
780 return jjMoveStringLiteralDfa5_3(active0, 0x400000L);
781 case 116:
782 if ((active0 & 0x40000L) != 0L)
783 {
784 jjmatchedKind = 18;
785 jjmatchedPos = 4;
786 }
787 return jjMoveStringLiteralDfa5_3(active0, 0x80000L);
788 default :
789 break;
790 }
791 return jjStartNfa_3(3, active0);
792 }
793 private final int jjMoveStringLiteralDfa5_3(long old0, long active0)
794 {
795 if (((active0 &= old0)) == 0L)
796 return jjStartNfa_3(3, old0);
797 try { curChar = input_stream.readChar(); }
798 catch(java.io.IOException e) {
799 jjStopStringLiteralDfa_3(4, active0);
800 return 5;
801 }
802 switch(curChar)
803 {
804 case 73:
805 return jjMoveStringLiteralDfa6_3(active0, 0x80000L);
806 case 114:
807 if ((active0 & 0x400000L) != 0L)
808 return jjStartNfaWithStates_3(5, 22, 1);
809 return jjMoveStringLiteralDfa6_3(active0, 0x2000000L);
810 case 116:
811 return jjMoveStringLiteralDfa6_3(active0, 0x200000L);
812 case 117:
813 return jjMoveStringLiteralDfa6_3(active0, 0x1000000L);
814 default :
815 break;
816 }
817 return jjStartNfa_3(4, active0);
818 }
819 private final int jjMoveStringLiteralDfa6_3(long old0, long active0)
820 {
821 if (((active0 &= old0)) == 0L)
822 return jjStartNfa_3(4, old0);
823 try { curChar = input_stream.readChar(); }
824 catch(java.io.IOException e) {
825 jjStopStringLiteralDfa_3(5, active0);
826 return 6;
827 }
828 switch(curChar)
829 {
830 case 101:
831 return jjMoveStringLiteralDfa7_3(active0, 0x200000L);
832 case 108:
833 if ((active0 & 0x2000000L) != 0L)
834 return jjStartNfaWithStates_3(6, 25, 1);
835 break;
836 case 109:
837 return jjMoveStringLiteralDfa7_3(active0, 0x1000000L);
838 case 116:
839 return jjMoveStringLiteralDfa7_3(active0, 0x80000L);
840 default :
841 break;
842 }
843 return jjStartNfa_3(5, active0);
844 }
845 private final int jjMoveStringLiteralDfa7_3(long old0, long active0)
846 {
847 if (((active0 &= old0)) == 0L)
848 return jjStartNfa_3(5, old0);
849 try { curChar = input_stream.readChar(); }
850 catch(java.io.IOException e) {
851 jjStopStringLiteralDfa_3(6, active0);
852 return 7;
853 }
854 switch(curChar)
855 {
856 case 98:
857 return jjMoveStringLiteralDfa8_3(active0, 0x1000000L);
858 case 101:
859 return jjMoveStringLiteralDfa8_3(active0, 0x80000L);
860 case 109:
861 if ((active0 & 0x200000L) != 0L)
862 return jjStartNfaWithStates_3(7, 21, 1);
863 break;
864 default :
865 break;
866 }
867 return jjStartNfa_3(6, active0);
868 }
869 private final int jjMoveStringLiteralDfa8_3(long old0, long active0)
870 {
871 if (((active0 &= old0)) == 0L)
872 return jjStartNfa_3(6, old0);
873 try { curChar = input_stream.readChar(); }
874 catch(java.io.IOException e) {
875 jjStopStringLiteralDfa_3(7, active0);
876 return 8;
877 }
878 switch(curChar)
879 {
880 case 101:
881 return jjMoveStringLiteralDfa9_3(active0, 0x1000000L);
882 case 109:
883 if ((active0 & 0x80000L) != 0L)
884 return jjStartNfaWithStates_3(8, 19, 1);
885 break;
886 default :
887 break;
888 }
889 return jjStartNfa_3(7, active0);
890 }
891 private final int jjMoveStringLiteralDfa9_3(long old0, long active0)
892 {
893 if (((active0 &= old0)) == 0L)
894 return jjStartNfa_3(7, old0);
895 try { curChar = input_stream.readChar(); }
896 catch(java.io.IOException e) {
897 jjStopStringLiteralDfa_3(8, active0);
898 return 9;
899 }
900 switch(curChar)
901 {
902 case 114:
903 if ((active0 & 0x1000000L) != 0L)
904 return jjStartNfaWithStates_3(9, 24, 1);
905 break;
906 default :
907 break;
908 }
909 return jjStartNfa_3(8, active0);
910 }
911 private final int jjMoveNfa_3(int startState, int curPos)
912 {
913 int[] nextStates;
914 int startsAt = 0;
915 jjnewStateCnt = 2;
916 int i = 1;
917 jjstateSet[0] = startState;
918 int j, kind = 0x7fffffff;
919 for (;;)
920 {
921 if (++jjround == 0x7fffffff)
922 ReInitRounds();
923 if (curChar < 64)
924 {
925 long l = 1L << curChar;
926 MatchLoop: do
927 {
928 switch(jjstateSet[--i])
929 {
930 case 0:
931 if (curChar != 36)
932 break;
933 if (kind > 27)
934 kind = 27;
935 jjCheckNAdd(1);
936 break;
937 case 1:
938 if ((0x3ff001000000000L & l) == 0L)
939 break;
940 if (kind > 27)
941 kind = 27;
942 jjCheckNAdd(1);
943 break;
944 default : break;
945 }
946 } while(i != startsAt);
947 }
948 else if (curChar < 128)
949 {
950 long l = 1L << (curChar & 077);
951 MatchLoop: do
952 {
953 switch(jjstateSet[--i])
954 {
955 case 0:
956 case 1:
957 if ((0x7fffffe87fffffeL & l) == 0L)
958 break;
959 if (kind > 27)
960 kind = 27;
961 jjCheckNAdd(1);
962 break;
963 default : break;
964 }
965 } while(i != startsAt);
966 }
967 else
968 {
969 int hiByte = (int)(curChar >> 8);
970 int i1 = hiByte >> 6;
971 long l1 = 1L << (hiByte & 077);
972 int i2 = (curChar & 0xff) >> 6;
973 long l2 = 1L << (curChar & 077);
974 MatchLoop: do
975 {
976 switch(jjstateSet[--i])
977 {
978 case 0:
979 case 1:
980 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
981 break;
982 if (kind > 27)
983 kind = 27;
984 jjCheckNAdd(1);
985 break;
986 default : break;
987 }
988 } while(i != startsAt);
989 }
990 if (kind != 0x7fffffff)
991 {
992 jjmatchedKind = kind;
993 jjmatchedPos = curPos;
994 kind = 0x7fffffff;
995 }
996 ++curPos;
997 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
998 return curPos;
999 try { curChar = input_stream.readChar(); }
1000 catch(java.io.IOException e) { return curPos; }
1001 }
1002}
1003private final int jjStopStringLiteralDfa_1(int pos, long active0)
1004{
1005 switch (pos)
1006 {
1007 case 0:
1008 if ((active0 & 0x3e00L) != 0L)
1009 {
1010 jjmatchedKind = 27;
1011 return 1;
1012 }
1013 return -1;
1014 case 1:
1015 if ((active0 & 0x3e00L) != 0L)
1016 {
1017 jjmatchedKind = 27;
1018 jjmatchedPos = 1;
1019 return 1;
1020 }
1021 return -1;
1022 case 2:
1023 if ((active0 & 0x3e00L) != 0L)
1024 {
1025 jjmatchedKind = 27;
1026 jjmatchedPos = 2;
1027 return 1;
1028 }
1029 return -1;
1030 case 3:
1031 if ((active0 & 0x3800L) != 0L)
1032 return 1;
1033 if ((active0 & 0x600L) != 0L)
1034 {
1035 if (jjmatchedPos != 3)
1036 {
1037 jjmatchedKind = 27;
1038 jjmatchedPos = 3;
1039 }
1040 return 1;
1041 }
1042 return -1;
1043 case 4:
1044 if ((active0 & 0x3600L) != 0L)
1045 {
1046 jjmatchedKind = 27;
1047 jjmatchedPos = 4;
1048 return 1;
1049 }
1050 return -1;
1051 case 5:
1052 if ((active0 & 0x600L) != 0L)
1053 return 1;
1054 if ((active0 & 0x3000L) != 0L)
1055 {
1056 jjmatchedKind = 27;
1057 jjmatchedPos = 5;
1058 return 1;
1059 }
1060 return -1;
1061 case 6:
1062 if ((active0 & 0x3000L) != 0L)
1063 {
1064 jjmatchedKind = 27;
1065 jjmatchedPos = 6;
1066 return 1;
1067 }
1068 return -1;
1069 case 7:
1070 if ((active0 & 0x3000L) != 0L)
1071 {
1072 jjmatchedKind = 27;
1073 jjmatchedPos = 7;
1074 return 1;
1075 }
1076 return -1;
1077 case 8:
1078 if ((active0 & 0x3000L) != 0L)
1079 {
1080 jjmatchedKind = 27;
1081 jjmatchedPos = 8;
1082 return 1;
1083 }
1084 return -1;
1085 default :
1086 return -1;
1087 }
1088}
1089private final int jjStartNfa_1(int pos, long active0)
1090{
1091 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
1092}
1093private final int jjStartNfaWithStates_1(int pos, int kind, int state)
1094{
1095 jjmatchedKind = kind;
1096 jjmatchedPos = pos;
1097 try { curChar = input_stream.readChar(); }
1098 catch(java.io.IOException e) { return pos + 1; }
1099 return jjMoveNfa_1(state, pos + 1);
1100}
1101private final int jjMoveStringLiteralDfa0_1()
1102{
1103 switch(curChar)
1104 {
1105 case 44:
1106 return jjStopAtPos(0, 7);
1107 case 59:
1108 return jjStopAtPos(0, 8);
1109 case 61:
1110 return jjStopAtPos(0, 6);
1111 case 110:
1112 return jjMoveStringLiteralDfa1_1(0x200L);
1113 case 111:
1114 return jjMoveStringLiteralDfa1_1(0x400L);
1115 case 112:
1116 return jjMoveStringLiteralDfa1_1(0x3800L);
1117 default :
1118 return jjMoveNfa_1(0, 0);
1119 }
1120}
1121private final int jjMoveStringLiteralDfa1_1(long active0)
1122{
1123 try { curChar = input_stream.readChar(); }
1124 catch(java.io.IOException e) {
1125 jjStopStringLiteralDfa_1(0, active0);
1126 return 1;
1127 }
1128 switch(curChar)
1129 {
1130 case 97:
1131 return jjMoveStringLiteralDfa2_1(active0, 0x3800L);
1132 case 102:
1133 return jjMoveStringLiteralDfa2_1(active0, 0x400L);
1134 case 117:
1135 return jjMoveStringLiteralDfa2_1(active0, 0x200L);
1136 default :
1137 break;
1138 }
1139 return jjStartNfa_1(0, active0);
1140}
1141private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
1142{
1143 if (((active0 &= old0)) == 0L)
1144 return jjStartNfa_1(0, old0);
1145 try { curChar = input_stream.readChar(); }
1146 catch(java.io.IOException e) {
1147 jjStopStringLiteralDfa_1(1, active0);
1148 return 2;
1149 }
1150 switch(curChar)
1151 {
1152 case 102:
1153 return jjMoveStringLiteralDfa3_1(active0, 0x400L);
1154 case 103:
1155 return jjMoveStringLiteralDfa3_1(active0, 0x3800L);
1156 case 109:
1157 return jjMoveStringLiteralDfa3_1(active0, 0x200L);
1158 default :
1159 break;
1160 }
1161 return jjStartNfa_1(1, active0);
1162}
1163private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
1164{
1165 if (((active0 &= old0)) == 0L)
1166 return jjStartNfa_1(1, old0);
1167 try { curChar = input_stream.readChar(); }
1168 catch(java.io.IOException e) {
1169 jjStopStringLiteralDfa_1(2, active0);
1170 return 3;
1171 }
1172 switch(curChar)
1173 {
1174 case 98:
1175 return jjMoveStringLiteralDfa4_1(active0, 0x200L);
1176 case 101:
1177 if ((active0 & 0x800L) != 0L)
1178 {
1179 jjmatchedKind = 11;
1180 jjmatchedPos = 3;
1181 }
1182 return jjMoveStringLiteralDfa4_1(active0, 0x3000L);
1183 case 115:
1184 return jjMoveStringLiteralDfa4_1(active0, 0x400L);
1185 default :
1186 break;
1187 }
1188 return jjStartNfa_1(2, active0);
1189}
1190private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
1191{
1192 if (((active0 &= old0)) == 0L)
1193 return jjStartNfa_1(2, old0);
1194 try { curChar = input_stream.readChar(); }
1195 catch(java.io.IOException e) {
1196 jjStopStringLiteralDfa_1(3, active0);
1197 return 4;
1198 }
1199 switch(curChar)
1200 {
1201 case 78:
1202 return jjMoveStringLiteralDfa5_1(active0, 0x1000L);
1203 case 79:
1204 return jjMoveStringLiteralDfa5_1(active0, 0x2000L);
1205 case 101:
1206 return jjMoveStringLiteralDfa5_1(active0, 0x600L);
1207 default :
1208 break;
1209 }
1210 return jjStartNfa_1(3, active0);
1211}
1212private final int jjMoveStringLiteralDfa5_1(long old0, long active0)
1213{
1214 if (((active0 &= old0)) == 0L)
1215 return jjStartNfa_1(3, old0);
1216 try { curChar = input_stream.readChar(); }
1217 catch(java.io.IOException e) {
1218 jjStopStringLiteralDfa_1(4, active0);
1219 return 5;
1220 }
1221 switch(curChar)
1222 {
1223 case 102:
1224 return jjMoveStringLiteralDfa6_1(active0, 0x2000L);
1225 case 114:
1226 if ((active0 & 0x200L) != 0L)
1227 return jjStartNfaWithStates_1(5, 9, 1);
1228 break;
1229 case 116:
1230 if ((active0 & 0x400L) != 0L)
1231 return jjStartNfaWithStates_1(5, 10, 1);
1232 break;
1233 case 117:
1234 return jjMoveStringLiteralDfa6_1(active0, 0x1000L);
1235 default :
1236 break;
1237 }
1238 return jjStartNfa_1(4, active0);
1239}
1240private final int jjMoveStringLiteralDfa6_1(long old0, long active0)
1241{
1242 if (((active0 &= old0)) == 0L)
1243 return jjStartNfa_1(4, old0);
1244 try { curChar = input_stream.readChar(); }
1245 catch(java.io.IOException e) {
1246 jjStopStringLiteralDfa_1(5, active0);
1247 return 6;
1248 }
1249 switch(curChar)
1250 {
1251 case 102:
1252 return jjMoveStringLiteralDfa7_1(active0, 0x2000L);
1253 case 109:
1254 return jjMoveStringLiteralDfa7_1(active0, 0x1000L);
1255 default :
1256 break;
1257 }
1258 return jjStartNfa_1(5, active0);
1259}
1260private final int jjMoveStringLiteralDfa7_1(long old0, long active0)
1261{
1262 if (((active0 &= old0)) == 0L)
1263 return jjStartNfa_1(5, old0);
1264 try { curChar = input_stream.readChar(); }
1265 catch(java.io.IOException e) {
1266 jjStopStringLiteralDfa_1(6, active0);
1267 return 7;
1268 }
1269 switch(curChar)
1270 {
1271 case 98:
1272 return jjMoveStringLiteralDfa8_1(active0, 0x1000L);
1273 case 115:
1274 return jjMoveStringLiteralDfa8_1(active0, 0x2000L);
1275 default :
1276 break;
1277 }
1278 return jjStartNfa_1(6, active0);
1279}
1280private final int jjMoveStringLiteralDfa8_1(long old0, long active0)
1281{
1282 if (((active0 &= old0)) == 0L)
1283 return jjStartNfa_1(6, old0);
1284 try { curChar = input_stream.readChar(); }
1285 catch(java.io.IOException e) {
1286 jjStopStringLiteralDfa_1(7, active0);
1287 return 8;
1288 }
1289 switch(curChar)
1290 {
1291 case 101:
1292 return jjMoveStringLiteralDfa9_1(active0, 0x3000L);
1293 default :
1294 break;
1295 }
1296 return jjStartNfa_1(7, active0);
1297}
1298private final int jjMoveStringLiteralDfa9_1(long old0, long active0)
1299{
1300 if (((active0 &= old0)) == 0L)
1301 return jjStartNfa_1(7, old0);
1302 try { curChar = input_stream.readChar(); }
1303 catch(java.io.IOException e) {
1304 jjStopStringLiteralDfa_1(8, active0);
1305 return 9;
1306 }
1307 switch(curChar)
1308 {
1309 case 114:
1310 if ((active0 & 0x1000L) != 0L)
1311 return jjStartNfaWithStates_1(9, 12, 1);
1312 break;
1313 case 116:
1314 if ((active0 & 0x2000L) != 0L)
1315 return jjStartNfaWithStates_1(9, 13, 1);
1316 break;
1317 default :
1318 break;
1319 }
1320 return jjStartNfa_1(8, active0);
1321}
1322private final int jjMoveNfa_1(int startState, int curPos)
1323{
1324 int[] nextStates;
1325 int startsAt = 0;
1326 jjnewStateCnt = 2;
1327 int i = 1;
1328 jjstateSet[0] = startState;
1329 int j, kind = 0x7fffffff;
1330 for (;;)
1331 {
1332 if (++jjround == 0x7fffffff)
1333 ReInitRounds();
1334 if (curChar < 64)
1335 {
1336 long l = 1L << curChar;
1337 MatchLoop: do
1338 {
1339 switch(jjstateSet[--i])
1340 {
1341 case 0:
1342 if (curChar != 36)
1343 break;
1344 if (kind > 27)
1345 kind = 27;
1346 jjCheckNAdd(1);
1347 break;
1348 case 1:
1349 if ((0x3ff001000000000L & l) == 0L)
1350 break;
1351 if (kind > 27)
1352 kind = 27;
1353 jjCheckNAdd(1);
1354 break;
1355 default : break;
1356 }
1357 } while(i != startsAt);
1358 }
1359 else if (curChar < 128)
1360 {
1361 long l = 1L << (curChar & 077);
1362 MatchLoop: do
1363 {
1364 switch(jjstateSet[--i])
1365 {
1366 case 0:
1367 case 1:
1368 if ((0x7fffffe87fffffeL & l) == 0L)
1369 break;
1370 if (kind > 27)
1371 kind = 27;
1372 jjCheckNAdd(1);
1373 break;
1374 default : break;
1375 }
1376 } while(i != startsAt);
1377 }
1378 else
1379 {
1380 int hiByte = (int)(curChar >> 8);
1381 int i1 = hiByte >> 6;
1382 long l1 = 1L << (hiByte & 077);
1383 int i2 = (curChar & 0xff) >> 6;
1384 long l2 = 1L << (curChar & 077);
1385 MatchLoop: do
1386 {
1387 switch(jjstateSet[--i])
1388 {
1389 case 0:
1390 case 1:
1391 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1392 break;
1393 if (kind > 27)
1394 kind = 27;
1395 jjCheckNAdd(1);
1396 break;
1397 default : break;
1398 }
1399 } while(i != startsAt);
1400 }
1401 if (kind != 0x7fffffff)
1402 {
1403 jjmatchedKind = kind;
1404 jjmatchedPos = curPos;
1405 kind = 0x7fffffff;
1406 }
1407 ++curPos;
1408 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
1409 return curPos;
1410 try { curChar = input_stream.readChar(); }
1411 catch(java.io.IOException e) { return curPos; }
1412 }
1413}
1414static final int[] jjnextStates = {
1415};
1416private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1417{
1418 switch(hiByte)
1419 {
1420 case 0:
1421 return ((jjbitVec2[i2] & l2) != 0L);
1422 case 48:
1423 return ((jjbitVec3[i2] & l2) != 0L);
1424 case 49:
1425 return ((jjbitVec4[i2] & l2) != 0L);
1426 case 51:
1427 return ((jjbitVec5[i2] & l2) != 0L);
1428 case 61:
1429 return ((jjbitVec6[i2] & l2) != 0L);
1430 default :
1431 if ((jjbitVec0[i1] & l1) != 0L)
1432 return true;
1433 return false;
1434 }
1435}
1436public static final String [] jjstrLiteralImages = {
1437"", null, null, null, null, null, "\75", "\54", "\73",
1438"\156\165\155\142\145\162", "\157\146\146\163\145\164", "\160\141\147\145",
1439"\160\141\147\145\116\165\155\142\145\162", "\160\141\147\145\117\146\146\163\145\164",
1440"\151\164\145\155\103\157\165\156\164", "\151\164\145\155\163", "\160\141\147\145\103\157\165\156\164",
1441"\160\141\147\145\163", "\146\151\162\163\164", "\146\151\162\163\164\111\164\145\155",
1442"\154\141\163\164", "\154\141\163\164\111\164\145\155", "\156\165\155\142\145\162",
1443"\160\141\147\145", "\160\141\147\145\116\165\155\142\145\162", "\160\141\147\145\125\162\154",
1444"\165\162\154", null, null, null, };
1445public static final String [] lexStateNames = {
1446 "DEFAULT",
1447 "PAGER_STATE",
1448 "INDEX_STATE",
1449 "PAGE_STATE",
1450};
1451public static final int[] jjnewLexState = {
1452 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1453 -1, -1, -1, -1, -1,
1454};
1455static final long[] jjtoToken = {
1456 0xfffffc1L,
1457};
1458static final long[] jjtoSkip = {
1459 0x3eL,
1460};
1461private JavaCharStream input_stream;
1462private final int[] jjrounds = new int[2];
1463private final int[] jjstateSet = new int[4];
1464protected char curChar;
1465public TagExportParserTokenManager(JavaCharStream stream)
1466{
1467 if (JavaCharStream.staticFlag)
1468 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1469 input_stream = stream;
1470}
1471public TagExportParserTokenManager(JavaCharStream stream, int lexState)
1472{
1473 this(stream);
1474 SwitchTo(lexState);
1475}
1476public void ReInit(JavaCharStream stream)
1477{
1478 jjmatchedPos = jjnewStateCnt = 0;
1479 curLexState = defaultLexState;
1480 input_stream = stream;
1481 ReInitRounds();
1482}
1483private final void ReInitRounds()
1484{
1485 int i;
1486 jjround = 0x80000001;
1487 for (i = 2; i-- > 0;)
1488 jjrounds[i] = 0x80000000;
1489}
1490public void ReInit(JavaCharStream stream, int lexState)
1491{
1492 ReInit(stream);
1493 SwitchTo(lexState);
1494}
1495public void SwitchTo(int lexState)
1496{
1497 if (lexState >= 4 || lexState < 0)
1498 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1499 else
1500 curLexState = lexState;
1501}
1502
1503private final Token jjFillToken()
1504{
1505 Token t = Token.newToken(jjmatchedKind);
1506 t.kind = jjmatchedKind;
1507 String im = jjstrLiteralImages[jjmatchedKind];
1508 t.image = (im == null) ? input_stream.GetImage() : im;
1509 t.beginLine = input_stream.getBeginLine();
1510 t.beginColumn = input_stream.getBeginColumn();
1511 t.endLine = input_stream.getEndLine();
1512 t.endColumn = input_stream.getEndColumn();
1513 return t;
1514}
1515
1516int curLexState = 0;
1517int defaultLexState = 0;
1518int jjnewStateCnt;
1519int jjround;
1520int jjmatchedPos;
1521int jjmatchedKind;
1522
1523public final Token getNextToken()
1524{
1525 int kind;
1526 Token specialToken = null;
1527 Token matchedToken;
1528 int curPos = 0;
1529
1530 EOFLoop :
1531 for (;;)
1532 {
1533 try
1534 {
1535 curChar = input_stream.BeginToken();
1536 }
1537 catch(java.io.IOException e)
1538 {
1539 jjmatchedKind = 0;
1540 matchedToken = jjFillToken();
1541 return matchedToken;
1542 }
1543
1544 switch(curLexState)
1545 {
1546 case 0:
1547 try { input_stream.backup(0);
1548 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1549 curChar = input_stream.BeginToken();
1550 }
1551 catch (java.io.IOException e1) { continue EOFLoop; }
1552 jjmatchedKind = 0x7fffffff;
1553 jjmatchedPos = 0;
1554 curPos = jjMoveStringLiteralDfa0_0();
1555 break;
1556 case 1:
1557 try { input_stream.backup(0);
1558 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1559 curChar = input_stream.BeginToken();
1560 }
1561 catch (java.io.IOException e1) { continue EOFLoop; }
1562 jjmatchedKind = 0x7fffffff;
1563 jjmatchedPos = 0;
1564 curPos = jjMoveStringLiteralDfa0_1();
1565 break;
1566 case 2:
1567 try { input_stream.backup(0);
1568 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1569 curChar = input_stream.BeginToken();
1570 }
1571 catch (java.io.IOException e1) { continue EOFLoop; }
1572 jjmatchedKind = 0x7fffffff;
1573 jjmatchedPos = 0;
1574 curPos = jjMoveStringLiteralDfa0_2();
1575 break;
1576 case 3:
1577 try { input_stream.backup(0);
1578 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1579 curChar = input_stream.BeginToken();
1580 }
1581 catch (java.io.IOException e1) { continue EOFLoop; }
1582 jjmatchedKind = 0x7fffffff;
1583 jjmatchedPos = 0;
1584 curPos = jjMoveStringLiteralDfa0_3();
1585 break;
1586 }
1587 if (jjmatchedKind != 0x7fffffff)
1588 {
1589 if (jjmatchedPos + 1 < curPos)
1590 input_stream.backup(curPos - jjmatchedPos - 1);
1591 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1592 {
1593 matchedToken = jjFillToken();
1594 if (jjnewLexState[jjmatchedKind] != -1)
1595 curLexState = jjnewLexState[jjmatchedKind];
1596 return matchedToken;
1597 }
1598 else
1599 {
1600 if (jjnewLexState[jjmatchedKind] != -1)
1601 curLexState = jjnewLexState[jjmatchedKind];
1602 continue EOFLoop;
1603 }
1604 }
1605 int error_line = input_stream.getEndLine();
1606 int error_column = input_stream.getEndColumn();
1607 String error_after = null;
1608 boolean EOFSeen = false;
1609 try { input_stream.readChar(); input_stream.backup(1); }
1610 catch (java.io.IOException e1) {
1611 EOFSeen = true;
1612 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1613 if (curChar == '\n' || curChar == '\r') {
1614 error_line++;
1615 error_column = 0;
1616 }
1617 else
1618 error_column++;
1619 }
1620 if (!EOFSeen) {
1621 input_stream.backup(1);
1622 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1623 }
1624 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1625 }
1626}
1627
1628}
1629 |
Popular Tags |
Java API By Example, From Geeks To Geeks.