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