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