|
1
2 package org.apache.taglibs.standard.lang.jstl.parser;
3
4 public class ELParserTokenManager implements ELParserConstants
5 {
6 public java.io.PrintStream  debugStream = System.out;
7 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
8 private final int jjStopStringLiteralDfa_0(int pos, long active0)
9 {
10 switch (pos)
11 {
12 case 0:
13 if ((active0 & 0x4L) != 0L)
14 {
15 jjmatchedKind = 1;
16 return 2;
17 }
18 return -1;
19 default :
20 return -1;
21 }
22 }
23 private final int jjStartNfa_0(int pos, long active0)
24 {
25 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
26 }
27 private final int jjStopAtPos(int pos, int kind)
28 {
29 jjmatchedKind = kind;
30 jjmatchedPos = pos;
31 return pos + 1;
32 }
33 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
34 {
35 jjmatchedKind = kind;
36 jjmatchedPos = pos;
37 try { curChar = input_stream.readChar(); }
38 catch(java.io.IOException e) { return pos + 1; }
39 return jjMoveNfa_0(state, pos + 1);
40 }
41 private final int jjMoveStringLiteralDfa0_0()
42 {
43 switch(curChar)
44 {
45 case 36:
46 return jjMoveStringLiteralDfa1_0(0x4L);
47 default :
48 return jjMoveNfa_0(1, 0);
49 }
50 }
51 private final int jjMoveStringLiteralDfa1_0(long active0)
52 {
53 try { curChar = input_stream.readChar(); }
54 catch(java.io.IOException e) {
55 jjStopStringLiteralDfa_0(0, active0);
56 return 1;
57 }
58 switch(curChar)
59 {
60 case 123:
61 if ((active0 & 0x4L) != 0L)
62 return jjStopAtPos(1, 2);
63 break;
64 default :
65 break;
66 }
67 return jjStartNfa_0(0, active0);
68 }
69 private final void jjCheckNAdd(int state)
70 {
71 if (jjrounds[state] != jjround)
72 {
73 jjstateSet[jjnewStateCnt++] = state;
74 jjrounds[state] = jjround;
75 }
76 }
77 private final void jjAddStates(int start, int end)
78 {
79 do {
80 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
81 } while (start++ != end);
82 }
83 private final void jjCheckNAddTwoStates(int state1, int state2)
84 {
85 jjCheckNAdd(state1);
86 jjCheckNAdd(state2);
87 }
88 private final void jjCheckNAddStates(int start, int end)
89 {
90 do {
91 jjCheckNAdd(jjnextStates[start]);
92 } while (start++ != end);
93 }
94 private final void jjCheckNAddStates(int start)
95 {
96 jjCheckNAdd(jjnextStates[start]);
97 jjCheckNAdd(jjnextStates[start + 1]);
98 }
99 static final long[] jjbitVec0 = {
100 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
101 };
102 static final long[] jjbitVec2 = {
103 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
104 };
105 private final int jjMoveNfa_0(int startState, int curPos)
106 {
107 int[] nextStates;
108 int startsAt = 0;
109 jjnewStateCnt = 3;
110 int i = 1;
111 jjstateSet[0] = startState;
112 int j, kind = 0x7fffffff;
113 for (;;)
114 {
115 if (++jjround == 0x7fffffff)
116 ReInitRounds();
117 if (curChar < 64)
118 {
119 long l = 1L << curChar;
120 MatchLoop: do
121 {
122 switch(jjstateSet[--i])
123 {
124 case 1:
125 if ((0xffffffefffffffffL & l) != 0L)
126 {
127 if (kind > 1)
128 kind = 1;
129 jjCheckNAdd(0);
130 }
131 else if (curChar == 36)
132 {
133 if (kind > 1)
134 kind = 1;
135 jjCheckNAdd(2);
136 }
137 break;
138 case 0:
139 if ((0xffffffefffffffffL & l) == 0L)
140 break;
141 if (kind > 1)
142 kind = 1;
143 jjCheckNAdd(0);
144 break;
145 case 2:
146 if ((0xffffffefffffffffL & l) == 0L)
147 break;
148 if (kind > 1)
149 kind = 1;
150 jjCheckNAdd(2);
151 break;
152 default : break;
153 }
154 } while(i != startsAt);
155 }
156 else if (curChar < 128)
157 {
158 long l = 1L << (curChar & 077);
159 MatchLoop: do
160 {
161 switch(jjstateSet[--i])
162 {
163 case 1:
164 case 0:
165 if (kind > 1)
166 kind = 1;
167 jjCheckNAdd(0);
168 break;
169 case 2:
170 if ((0xf7ffffffffffffffL & l) == 0L)
171 break;
172 if (kind > 1)
173 kind = 1;
174 jjstateSet[jjnewStateCnt++] = 2;
175 break;
176 default : break;
177 }
178 } while(i != startsAt);
179 }
180 else
181 {
182 int hiByte = (int)(curChar >> 8);
183 int i1 = hiByte >> 6;
184 long l1 = 1L << (hiByte & 077);
185 int i2 = (curChar & 0xff) >> 6;
186 long l2 = 1L << (curChar & 077);
187 MatchLoop: do
188 {
189 switch(jjstateSet[--i])
190 {
191 case 1:
192 case 0:
193 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
194 break;
195 if (kind > 1)
196 kind = 1;
197 jjCheckNAdd(0);
198 break;
199 case 2:
200 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
201 break;
202 if (kind > 1)
203 kind = 1;
204 jjstateSet[jjnewStateCnt++] = 2;
205 break;
206 default : break;
207 }
208 } while(i != startsAt);
209 }
210 if (kind != 0x7fffffff)
211 {
212 jjmatchedKind = kind;
213 jjmatchedPos = curPos;
214 kind = 0x7fffffff;
215 }
216 ++curPos;
217 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
218 return curPos;
219 try { curChar = input_stream.readChar(); }
220 catch(java.io.IOException e) { return curPos; }
221 }
222 }
223 private final int jjStopStringLiteralDfa_1(int pos, long active0)
224 {
225 switch (pos)
226 {
227 case 0:
228 if ((active0 & 0x1568015547000L) != 0L)
229 {
230 jjmatchedKind = 49;
231 return 6;
232 }
233 if ((active0 & 0x10000L) != 0L)
234 return 1;
235 return -1;
236 case 1:
237 if ((active0 & 0x400015540000L) != 0L)
238 return 6;
239 if ((active0 & 0x1168000007000L) != 0L)
240 {
241 jjmatchedKind = 49;
242 jjmatchedPos = 1;
243 return 6;
244 }
245 return -1;
246 case 2:
247 if ((active0 & 0x168000000000L) != 0L)
248 return 6;
249 if ((active0 & 0x1000000007000L) != 0L)
250 {
251 jjmatchedKind = 49;
252 jjmatchedPos = 2;
253 return 6;
254 }
255 return -1;
256 case 3:
257 if ((active0 & 0x5000L) != 0L)
258 return 6;
259 if ((active0 & 0x1000000002000L) != 0L)
260 {
261 jjmatchedKind = 49;
262 jjmatchedPos = 3;
263 return 6;
264 }
265 return -1;
266 default :
267 return -1;
268 }
269 }
270 private final int jjStartNfa_1(int pos, long active0)
271 {
272 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
273 }
274 private final int jjStartNfaWithStates_1(int pos, int kind, int state)
275 {
276 jjmatchedKind = kind;
277 jjmatchedPos = pos;
278 try { curChar = input_stream.readChar(); }
279 catch(java.io.IOException e) { return pos + 1; }
280 return jjMoveNfa_1(state, pos + 1);
281 }
282 private final int jjMoveStringLiteralDfa0_1()
283 {
284 switch(curChar)
285 {
286 case 33:
287 jjmatchedKind = 43;
288 return jjMoveStringLiteralDfa1_1(0x8000000L);
289 case 37:
290 return jjStopAtPos(0, 40);
291 case 38:
292 return jjMoveStringLiteralDfa1_1(0x200000000000L);
293 case 40:
294 return jjStopAtPos(0, 29);
295 case 41:
296 return jjStopAtPos(0, 30);
297 case 42:
298 return jjStopAtPos(0, 37);
299 case 43:
300 return jjStopAtPos(0, 35);
301 case 44:
302 return jjStopAtPos(0, 31);
303 case 45:
304 return jjStopAtPos(0, 36);
305 case 46:
306 return jjStartNfaWithStates_1(0, 16, 1);
307 case 47:
308 return jjStopAtPos(0, 38);
309 case 58:
310 return jjStopAtPos(0, 32);
311 case 60:
312 jjmatchedKind = 19;
313 return jjMoveStringLiteralDfa1_1(0x800000L);
314 case 61:
315 return jjMoveStringLiteralDfa1_1(0x200000L);
316 case 62:
317 jjmatchedKind = 17;
318 return jjMoveStringLiteralDfa1_1(0x2000000L);
319 case 91:
320 return jjStopAtPos(0, 33);
321 case 93:
322 return jjStopAtPos(0, 34);
323 case 97:
324 return jjMoveStringLiteralDfa1_1(0x100000000000L);
325 case 100:
326 return jjMoveStringLiteralDfa1_1(0x8000000000L);
327 case 101:
328 return jjMoveStringLiteralDfa1_1(0x1000000400000L);
329 case 102:
330 return jjMoveStringLiteralDfa1_1(0x2000L);
331 case 103:
332 return jjMoveStringLiteralDfa1_1(0x4040000L);
333 case 108:
334 return jjMoveStringLiteralDfa1_1(0x1100000L);
335 case 109:
336 return jjMoveStringLiteralDfa1_1(0x20000000000L);
337 case 110:
338 return jjMoveStringLiteralDfa1_1(0x40010004000L);
339 case 111:
340 return jjMoveStringLiteralDfa1_1(0x400000000000L);
341 case 116:
342 return jjMoveStringLiteralDfa1_1(0x1000L);
343 case 124:
344 return jjMoveStringLiteralDfa1_1(0x800000000000L);
345 case 125:
346 return jjStopAtPos(0, 15);
347 default :
348 return jjMoveNfa_1(0, 0);
349 }
350 }
351 private final int jjMoveStringLiteralDfa1_1(long active0)
352 {
353 try { curChar = input_stream.readChar(); }
354 catch(java.io.IOException e) {
355 jjStopStringLiteralDfa_1(0, active0);
356 return 1;
357 }
358 switch(curChar)
359 {
360 case 38:
361 if ((active0 & 0x200000000000L) != 0L)
362 return jjStopAtPos(1, 45);
363 break;
364 case 61:
365 if ((active0 & 0x200000L) != 0L)
366 return jjStopAtPos(1, 21);
367 else if ((active0 & 0x800000L) != 0L)
368 return jjStopAtPos(1, 23);
369 else if ((active0 & 0x2000000L) != 0L)
370 return jjStopAtPos(1, 25);
371 else if ((active0 & 0x8000000L) != 0L)
372 return jjStopAtPos(1, 27);
373 break;
374 case 97:
375 return jjMoveStringLiteralDfa2_1(active0, 0x2000L);
376 case 101:
377 if ((active0 & 0x1000000L) != 0L)
378 return jjStartNfaWithStates_1(1, 24, 6);
379 else if ((active0 & 0x4000000L) != 0L)
380 return jjStartNfaWithStates_1(1, 26, 6);
381 else if ((active0 & 0x10000000L) != 0L)
382 return jjStartNfaWithStates_1(1, 28, 6);
383 break;
384 case 105:
385 return jjMoveStringLiteralDfa2_1(active0, 0x8000000000L);
386 case 109:
387 return jjMoveStringLiteralDfa2_1(active0, 0x1000000000000L);
388 case 110:
389 return jjMoveStringLiteralDfa2_1(active0, 0x100000000000L);
390 case 111:
391 return jjMoveStringLiteralDfa2_1(active0, 0x60000000000L);
392 case 113:
393 if ((active0 & 0x400000L) != 0L)
394 return jjStartNfaWithStates_1(1, 22, 6);
395 break;
396 case 114:
397 if ((active0 & 0x400000000000L) != 0L)
398 return jjStartNfaWithStates_1(1, 46, 6);
399 return jjMoveStringLiteralDfa2_1(active0, 0x1000L);
400 case 116:
401 if ((active0 & 0x40000L) != 0L)
402 return jjStartNfaWithStates_1(1, 18, 6);
403 else if ((active0 & 0x100000L) != 0L)
404 return jjStartNfaWithStates_1(1, 20, 6);
405 break;
406 case 117:
407 return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
408 case 124:
409 if ((active0 & 0x800000000000L) != 0L)
410 return jjStopAtPos(1, 47);
411 break;
412 default :
413 break;
414 }
415 return jjStartNfa_1(0, active0);
416 }
417 private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
418 {
419 if (((active0 &= old0)) == 0L)
420 return jjStartNfa_1(0, old0);
421 try { curChar = input_stream.readChar(); }
422 catch(java.io.IOException e) {
423 jjStopStringLiteralDfa_1(1, active0);
424 return 2;
425 }
426 switch(curChar)
427 {
428 case 100:
429 if ((active0 & 0x20000000000L) != 0L)
430 return jjStartNfaWithStates_1(2, 41, 6);
431 else if ((active0 & 0x100000000000L) != 0L)
432 return jjStartNfaWithStates_1(2, 44, 6);
433 break;
434 case 108:
435 return jjMoveStringLiteralDfa3_1(active0, 0x6000L);
436 case 112:
437 return jjMoveStringLiteralDfa3_1(active0, 0x1000000000000L);
438 case 116:
439 if ((active0 & 0x40000000000L) != 0L)
440 return jjStartNfaWithStates_1(2, 42, 6);
441 break;
442 case 117:
443 return jjMoveStringLiteralDfa3_1(active0, 0x1000L);
444 case 118:
445 if ((active0 & 0x8000000000L) != 0L)
446 return jjStartNfaWithStates_1(2, 39, 6);
447 break;
448 default :
449 break;
450 }
451 return jjStartNfa_1(1, active0);
452 }
453 private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
454 {
455 if (((active0 &= old0)) == 0L)
456 return jjStartNfa_1(1, old0);
457 try { curChar = input_stream.readChar(); }
458 catch(java.io.IOException e) {
459 jjStopStringLiteralDfa_1(2, active0);
460 return 3;
461 }
462 switch(curChar)
463 {
464 case 101:
465 if ((active0 & 0x1000L) != 0L)
466 return jjStartNfaWithStates_1(3, 12, 6);
467 break;
468 case 108:
469 if ((active0 & 0x4000L) != 0L)
470 return jjStartNfaWithStates_1(3, 14, 6);
471 break;
472 case 115:
473 return jjMoveStringLiteralDfa4_1(active0, 0x2000L);
474 case 116:
475 return jjMoveStringLiteralDfa4_1(active0, 0x1000000000000L);
476 default :
477 break;
478 }
479 return jjStartNfa_1(2, active0);
480 }
481 private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
482 {
483 if (((active0 &= old0)) == 0L)
484 return jjStartNfa_1(2, old0);
485 try { curChar = input_stream.readChar(); }
486 catch(java.io.IOException e) {
487 jjStopStringLiteralDfa_1(3, active0);
488 return 4;
489 }
490 switch(curChar)
491 {
492 case 101:
493 if ((active0 & 0x2000L) != 0L)
494 return jjStartNfaWithStates_1(4, 13, 6);
495 break;
496 case 121:
497 if ((active0 & 0x1000000000000L) != 0L)
498 return jjStartNfaWithStates_1(4, 48, 6);
499 break;
500 default :
501 break;
502 }
503 return jjStartNfa_1(3, active0);
504 }
505 static final long[] jjbitVec3 = {
506 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
507 };
508 static final long[] jjbitVec4 = {
509 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
510 };
511 static final long[] jjbitVec5 = {
512 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
513 };
514 static final long[] jjbitVec6 = {
515 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
516 };
517 static final long[] jjbitVec7 = {
518 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
519 };
520 static final long[] jjbitVec8 = {
521 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
522 };
523 private final int jjMoveNfa_1(int startState, int curPos)
524 {
525 int[] nextStates;
526 int startsAt = 0;
527 jjnewStateCnt = 35;
528 int i = 1;
529 jjstateSet[0] = startState;
530 int j, kind = 0x7fffffff;
531 for (;;)
532 {
533 if (++jjround == 0x7fffffff)
534 ReInitRounds();
535 if (curChar < 64)
536 {
537 long l = 1L << curChar;
538 MatchLoop: do
539 {
540 switch(jjstateSet[--i])
541 {
542 case 0:
543 if ((0x3ff000000000000L & l) != 0L)
544 {
545 if (kind > 7)
546 kind = 7;
547 jjCheckNAddStates(0, 4);
548 }
549 else if ((0x1800000000L & l) != 0L)
550 {
551 if (kind > 49)
552 kind = 49;
553 jjCheckNAdd(6);
554 }
555 else if (curChar == 39)
556 jjCheckNAddStates(5, 9);
557 else if (curChar == 34)
558 jjCheckNAddStates(10, 14);
559 else if (curChar == 46)
560 jjCheckNAdd(1);
561 break;
562 case 1:
563 if ((0x3ff000000000000L & l) == 0L)
564 break;
565 if (kind > 8)
566 kind = 8;
567 jjCheckNAddTwoStates(1, 2);
568 break;
569 case 3:
570 if ((0x280000000000L & l) != 0L)
571 jjCheckNAdd(4);
572 break;
573 case 4:
574 if ((0x3ff000000000000L & l) == 0L)
575 break;
576 if (kind > 8)
577 kind = 8;
578 jjCheckNAdd(4);
579 break;
580 case 5:
581 if ((0x1800000000L & l) == 0L)
582 break;
583 if (kind > 49)
584 kind = 49;
585 jjCheckNAdd(6);
586 break;
587 case 6:
588 if ((0x3ff001000000000L & l) == 0L)
589 break;
590 if (kind > 49)
591 kind = 49;
592 jjCheckNAdd(6);
593 break;
594 case 7:
595 if ((0x3ff000000000000L & l) == 0L)
596 break;
597 if (kind > 7)
598 kind = 7;
599 jjCheckNAddStates(0, 4);
600 break;
601 case 8:
602 if ((0x3ff000000000000L & l) == 0L)
603 break;
604 if (kind > 7)
605 kind = 7;
606 jjCheckNAdd(8);
607 break;
608 case 9:
609 if ((0x3ff000000000000L & l) != 0L)
610 jjCheckNAddTwoStates(9, 10);
611 break;
612 case 10:
613 if (curChar != 46)
614 break;
615 if (kind > 8)
616 kind = 8;
617 jjCheckNAddTwoStates(11, 12);
618 break;
619 case 11:
620 if ((0x3ff000000000000L & l) == 0L)
621 break;
622 if (kind > 8)
623 kind = 8;
624 jjCheckNAddTwoStates(11, 12);
625 break;
626 case 13:
627 if ((0x280000000000L & l) != 0L)
628 jjCheckNAdd(14);
629 break;
630 case 14:
631 if ((0x3ff000000000000L & l) == 0L)
632 break;
633 if (kind > 8)
634 kind = 8;
635 jjCheckNAdd(14);
636 break;
637 case 15:
638 if ((0x3ff000000000000L & l) != 0L)
639 jjCheckNAddTwoStates(15, 16);
640 break;
641 case 17:
642 if ((0x280000000000L & l) != 0L)
643 jjCheckNAdd(18);
644 break;
645 case 18:
646 if ((0x3ff000000000000L & l) == 0L)
647 break;
648 if (kind > 8)
649 kind = 8;
650 jjCheckNAdd(18);
651 break;
652 case 19:
653 if (curChar == 34)
654 jjCheckNAddStates(10, 14);
655 break;
656 case 20:
657 if ((0xfffffffbffffffffL & l) != 0L)
658 jjCheckNAddStates(15, 17);
659 break;
660 case 22:
661 if (curChar == 34)
662 jjCheckNAddStates(15, 17);
663 break;
664 case 23:
665 if (curChar == 34 && kind > 10)
666 kind = 10;
667 break;
668 case 24:
669 if ((0xfffffffbffffffffL & l) != 0L)
670 jjCheckNAddTwoStates(24, 25);
671 break;
672 case 26:
673 if ((0xfffffffbffffffffL & l) != 0L && kind > 11)
674 kind = 11;
675 break;
676 case 27:
677 if (curChar == 39)
678 jjCheckNAddStates(5, 9);
679 break;
680 case 28:
681 if ((0xffffff7fffffffffL & l) != 0L)
682 jjCheckNAddStates(18, 20);
683 break;
684 case 30:
685 if (curChar == 39)
686 jjCheckNAddStates(18, 20);
687 break;
688 case 31:
689 if (curChar == 39 && kind > 10)
690 kind = 10;
691 break;
692 case 32:
693 if ((0xffffff7fffffffffL & l) != 0L)
694 jjCheckNAddTwoStates(32, 33);
695 break;
696 case 34:
697 if ((0xffffff7fffffffffL & l) != 0L && kind > 11)
698 kind = 11;
699 break;
700 default : break;
701 }
702 } while(i != startsAt);
703 }
704 else if (curChar < 128)
705 {
706 long l = 1L << (curChar & 077);
707 MatchLoop: do
708 {
709 switch(jjstateSet[--i])
710 {
711 case 0:
712 case 6:
713 if ((0x7fffffe87fffffeL & l) == 0L)
714 break;
715 if (kind > 49)
716 kind = 49;
717 jjCheckNAdd(6);
718 break;
719 case 2:
720 if ((0x2000000020L & l) != 0L)
721 jjAddStates(21, 22);
722 break;
723 case 12:
724 if ((0x2000000020L & l) != 0L)
725 jjAddStates(23, 24);
726 break;
727 case 16:
728 if ((0x2000000020L & l) != 0L)
729 jjAddStates(25, 26);
730 break;
731 case 20:
732 if ((0xffffffffefffffffL & l) != 0L)
733 jjCheckNAddStates(15, 17);
734 break;
735 case 21:
736 if (curChar == 92)
737 jjstateSet[jjnewStateCnt++] = 22;
738 break;
739 case 22:
740 if (curChar == 92)
741 jjCheckNAddStates(15, 17);
742 break;
743 case 24:
744 if ((0xffffffffefffffffL & l) != 0L)
745 jjAddStates(27, 28);
746 break;
747 case 25:
748 if (curChar == 92)
749 jjstateSet[jjnewStateCnt++] = 26;
750 break;
751 case 26:
752 case 34:
753 if ((0xffffffffefffffffL & l) != 0L && kind > 11)
754 kind = 11;
755 break;
756 case 28:
757 if ((0xffffffffefffffffL & l) != 0L)
758 jjCheckNAddStates(18, 20);
759 break;
760 case 29:
761 if (curChar == 92)
762 jjstateSet[jjnewStateCnt++] = 30;
763 break;
764 case 30:
765 if (curChar == 92)
766 jjCheckNAddStates(18, 20);
767 break;
768 case 32:
769 if ((0xffffffffefffffffL & l) != 0L)
770 jjAddStates(29, 30);
771 break;
772 case 33:
773 if (curChar == 92)
774 jjstateSet[jjnewStateCnt++] = 34;
775 break;
776 default : break;
777 }
778 } while(i != startsAt);
779 }
780 else
781 {
782 int hiByte = (int)(curChar >> 8);
783 int i1 = hiByte >> 6;
784 long l1 = 1L << (hiByte & 077);
785 int i2 = (curChar & 0xff) >> 6;
786 long l2 = 1L << (curChar & 077);
787 MatchLoop: do
788 {
789 switch(jjstateSet[--i])
790 {
791 case 0:
792 case 6:
793 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
794 break;
795 if (kind > 49)
796 kind = 49;
797 jjCheckNAdd(6);
798 break;
799 case 20:
800 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
801 jjAddStates(15, 17);
802 break;
803 case 24:
804 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
805 jjAddStates(27, 28);
806 break;
807 case 26:
808 case 34:
809 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 11)
810 kind = 11;
811 break;
812 case 28:
813 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
814 jjAddStates(18, 20);
815 break;
816 case 32:
817 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
818 jjAddStates(29, 30);
819 break;
820 default : break;
821 }
822 } while(i != startsAt);
823 }
824 if (kind != 0x7fffffff)
825 {
826 jjmatchedKind = kind;
827 jjmatchedPos = curPos;
828 kind = 0x7fffffff;
829 }
830 ++curPos;
831 if ((i = jjnewStateCnt) == (startsAt = 35 - (jjnewStateCnt = startsAt)))
832 return curPos;
833 try { curChar = input_stream.readChar(); }
834 catch(java.io.IOException e) { return curPos; }
835 }
836 }
837 static final int[] jjnextStates = {
838 8, 9, 10, 15, 16, 28, 29, 31, 32, 33, 20, 21, 23, 24, 25, 20,
839 21, 23, 28, 29, 31, 3, 4, 13, 14, 17, 18, 24, 25, 32, 33,
840 };
841 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
842 {
843 switch(hiByte)
844 {
845 case 0:
846 return ((jjbitVec2[i2] & l2) != 0L);
847 default :
848 if ((jjbitVec0[i1] & l1) != 0L)
849 return true;
850 return false;
851 }
852 }
853 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
854 {
855 switch(hiByte)
856 {
857 case 0:
858 return ((jjbitVec4[i2] & l2) != 0L);
859 case 48:
860 return ((jjbitVec5[i2] & l2) != 0L);
861 case 49:
862 return ((jjbitVec6[i2] & l2) != 0L);
863 case 51:
864 return ((jjbitVec7[i2] & l2) != 0L);
865 case 61:
866 return ((jjbitVec8[i2] & l2) != 0L);
867 default :
868 if ((jjbitVec3[i1] & l1) != 0L)
869 return true;
870 return false;
871 }
872 }
873 public static final String [] jjstrLiteralImages = {
874 "", null, "\44\173", null, null, null, null, null, null, null, null, null,
875 "\164\162\165\145", "\146\141\154\163\145", "\156\165\154\154", "\175", "\56", "\76", "\147\164",
876 "\74", "\154\164", "\75\75", "\145\161", "\74\75", "\154\145", "\76\75", "\147\145",
877 "\41\75", "\156\145", "\50", "\51", "\54", "\72", "\133", "\135", "\53", "\55", "\52",
878 "\57", "\144\151\166", "\45", "\155\157\144", "\156\157\164", "\41", "\141\156\144",
879 "\46\46", "\157\162", "\174\174", "\145\155\160\164\171", null, null, null, null, null, };
880 public static final String [] lexStateNames = {
881 "DEFAULT",
882 "IN_EXPRESSION",
883 };
884 public static final int[] jjnewLexState = {
885 -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1,
886 -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,
887 -1, -1, -1, -1,
888 };
889 static final long[] jjtoToken = {
890 0x23fffffffffd87L,
891 };
892 static final long[] jjtoSkip = {
893 0x78L,
894 };
895 private SimpleCharStream input_stream;
896 private final int[] jjrounds = new int[35];
897 private final int[] jjstateSet = new int[70];
898 protected char curChar;
899 public ELParserTokenManager(SimpleCharStream stream)
900 {
901 if (SimpleCharStream.staticFlag)
902 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
903 input_stream = stream;
904 }
905 public ELParserTokenManager(SimpleCharStream stream, int lexState)
906 {
907 this(stream);
908 SwitchTo(lexState);
909 }
910 public void ReInit(SimpleCharStream stream)
911 {
912 jjmatchedPos = jjnewStateCnt = 0;
913 curLexState = defaultLexState;
914 input_stream = stream;
915 ReInitRounds();
916 }
917 private final void ReInitRounds()
918 {
919 int i;
920 jjround = 0x80000001;
921 for (i = 35; i-- > 0;)
922 jjrounds[i] = 0x80000000;
923 }
924 public void ReInit(SimpleCharStream stream, int lexState)
925 {
926 ReInit(stream);
927 SwitchTo(lexState);
928 }
929 public void SwitchTo(int lexState)
930 {
931 if (lexState >= 2 || lexState < 0)
932 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
933 else
934 curLexState = lexState;
935 }
936
937 private final Token jjFillToken()
938 {
939 Token t = Token.newToken(jjmatchedKind);
940 t.kind = jjmatchedKind;
941 String im = jjstrLiteralImages[jjmatchedKind];
942 t.image = (im == null) ? input_stream.GetImage() : im;
943 t.beginLine = input_stream.getBeginLine();
944 t.beginColumn = input_stream.getBeginColumn();
945 t.endLine = input_stream.getEndLine();
946 t.endColumn = input_stream.getEndColumn();
947 return t;
948 }
949
950 int curLexState = 0;
951 int defaultLexState = 0;
952 int jjnewStateCnt;
953 int jjround;
954 int jjmatchedPos;
955 int jjmatchedKind;
956
957 public final Token getNextToken()
958 {
959 int kind;
960 Token specialToken = null;
961 Token matchedToken;
962 int curPos = 0;
963
964 EOFLoop :
965 for (;;)
966 {
967 try
968 {
969 curChar = input_stream.BeginToken();
970 }
971 catch(java.io.IOException e)
972 {
973 jjmatchedKind = 0;
974 matchedToken = jjFillToken();
975 return matchedToken;
976 }
977
978 switch(curLexState)
979 {
980 case 0:
981 jjmatchedKind = 0x7fffffff;
982 jjmatchedPos = 0;
983 curPos = jjMoveStringLiteralDfa0_0();
984 break;
985 case 1:
986 try { input_stream.backup(0);
987 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
988 curChar = input_stream.BeginToken();
989 }
990 catch (java.io.IOException e1) { continue EOFLoop; }
991 jjmatchedKind = 0x7fffffff;
992 jjmatchedPos = 0;
993 curPos = jjMoveStringLiteralDfa0_1();
994 if (jjmatchedPos == 0 && jjmatchedKind > 53)
995 {
996 jjmatchedKind = 53;
997 }
998 break;
999 }
1000 if (jjmatchedKind != 0x7fffffff)
1001 {
1002 if (jjmatchedPos + 1 < curPos)
1003 input_stream.backup(curPos - jjmatchedPos - 1);
1004 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1005 {
1006 matchedToken = jjFillToken();
1007 if (jjnewLexState[jjmatchedKind] != -1)
1008 curLexState = jjnewLexState[jjmatchedKind];
1009 return matchedToken;
1010 }
1011 else
1012 {
1013 if (jjnewLexState[jjmatchedKind] != -1)
1014 curLexState = jjnewLexState[jjmatchedKind];
1015 continue EOFLoop;
1016 }
1017 }
1018 int error_line = input_stream.getEndLine();
1019 int error_column = input_stream.getEndColumn();
1020 String error_after = null;
1021 boolean EOFSeen = false;
1022 try { input_stream.readChar(); input_stream.backup(1); }
1023 catch (java.io.IOException e1) {
1024 EOFSeen = true;
1025 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1026 if (curChar == '\n' || curChar == '\r') {
1027 error_line++;
1028 error_column = 0;
1029 }
1030 else
1031 error_column++;
1032 }
1033 if (!EOFSeen) {
1034 input_stream.backup(1);
1035 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1036 }
1037 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1038 }
1039}
1040
1041}
1042 |
Popular Tags |
Java API By Example, From Geeks To Geeks.