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