1
2 package com.randomnoun.common.jexl.parser;
3 import java.io.*;
4 import com.randomnoun.common.jexl.ast.*;
5 import java.util.Vector;
6
7
8 public class ExpressionParserTokenManager implements ExpressionParserConstants
9 {
10
11
12 public java.io.PrintStream debugStream = System.out;
13
14 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
15 private final int jjStopStringLiteralDfa_0(int pos, long active0)
16 {
17 switch (pos)
18 {
19 case 0:
20 if ((active0 & 0xe000L) != 0L)
21 {
22 jjmatchedKind = 16;
23 return 27;
24 }
25 if ((active0 & 0x1000000000L) != 0L)
26 return 7;
27 return -1;
28 case 1:
29 if ((active0 & 0xe000L) != 0L)
30 {
31 jjmatchedKind = 16;
32 jjmatchedPos = 1;
33 return 27;
34 }
35 return -1;
36 case 2:
37 if ((active0 & 0xe000L) != 0L)
38 {
39 jjmatchedKind = 16;
40 jjmatchedPos = 2;
41 return 27;
42 }
43 return -1;
44 case 3:
45 if ((active0 & 0x8000L) != 0L)
46 {
47 jjmatchedKind = 16;
48 jjmatchedPos = 3;
49 return 27;
50 }
51 if ((active0 & 0x6000L) != 0L)
52 return 27;
53 return -1;
54 default :
55 return -1;
56 }
57 }
58 private final int jjStartNfa_0(int pos, long active0)
59 {
60 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
61 }
62 private int jjStopAtPos(int pos, int kind)
63 {
64 jjmatchedKind = kind;
65 jjmatchedPos = pos;
66 return pos + 1;
67 }
68 private int jjMoveStringLiteralDfa0_0()
69 {
70 switch(curChar)
71 {
72 case 33:
73 jjmatchedKind = 33;
74 return jjMoveStringLiteralDfa1_0(0x400000L);
75 case 37:
76 return jjStopAtPos(0, 31);
77 case 38:
78 return jjMoveStringLiteralDfa1_0(0x100000L);
79 case 40:
80 return jjStopAtPos(0, 34);
81 case 41:
82 return jjStopAtPos(0, 35);
83 case 42:
84 return jjStopAtPos(0, 29);
85 case 43:
86 return jjStopAtPos(0, 27);
87 case 44:
88 return jjStopAtPos(0, 37);
89 case 45:
90 return jjStopAtPos(0, 28);
91 case 46:
92 return jjStartNfaWithStates_0(0, 36, 7);
93 case 47:
94 return jjStopAtPos(0, 30);
95 case 60:
96 jjmatchedKind = 23;
97 return jjMoveStringLiteralDfa1_0(0x2000000L);
98 case 61:
99 return jjMoveStringLiteralDfa1_0(0x200000L);
100 case 62:
101 jjmatchedKind = 24;
102 return jjMoveStringLiteralDfa1_0(0x4000000L);
103 case 102:
104 return jjMoveStringLiteralDfa1_0(0x8000L);
105 case 110:
106 return jjMoveStringLiteralDfa1_0(0x4000L);
107 case 116:
108 return jjMoveStringLiteralDfa1_0(0x2000L);
109 case 124:
110 return jjMoveStringLiteralDfa1_0(0x80000L);
111 case 126:
112 return jjStopAtPos(0, 32);
113 default :
114 return jjMoveNfa_0(0, 0);
115 }
116 }
117 private int jjMoveStringLiteralDfa1_0(long active0)
118 {
119 try { curChar = input_stream.readChar(); }
120 catch(java.io.IOException e) {
121 jjStopStringLiteralDfa_0(0, active0);
122 return 1;
123 }
124 switch(curChar)
125 {
126 case 38:
127 if ((active0 & 0x100000L) != 0L)
128 return jjStopAtPos(1, 20);
129 break;
130 case 61:
131 if ((active0 & 0x200000L) != 0L)
132 return jjStopAtPos(1, 21);
133 else if ((active0 & 0x400000L) != 0L)
134 return jjStopAtPos(1, 22);
135 else if ((active0 & 0x2000000L) != 0L)
136 return jjStopAtPos(1, 25);
137 else if ((active0 & 0x4000000L) != 0L)
138 return jjStopAtPos(1, 26);
139 break;
140 case 97:
141 return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
142 case 114:
143 return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
144 case 117:
145 return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
146 case 124:
147 if ((active0 & 0x80000L) != 0L)
148 return jjStopAtPos(1, 19);
149 break;
150 default :
151 break;
152 }
153 return jjStartNfa_0(0, active0);
154 }
155 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
156 {
157 if (((active0 &= old0)) == 0L)
158 return jjStartNfa_0(0, old0);
159 try { curChar = input_stream.readChar(); }
160 catch(java.io.IOException e) {
161 jjStopStringLiteralDfa_0(1, active0);
162 return 2;
163 }
164 switch(curChar)
165 {
166 case 108:
167 return jjMoveStringLiteralDfa3_0(active0, 0xc000L);
168 case 117:
169 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
170 default :
171 break;
172 }
173 return jjStartNfa_0(1, active0);
174 }
175 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
176 {
177 if (((active0 &= old0)) == 0L)
178 return jjStartNfa_0(1, old0);
179 try { curChar = input_stream.readChar(); }
180 catch(java.io.IOException e) {
181 jjStopStringLiteralDfa_0(2, active0);
182 return 3;
183 }
184 switch(curChar)
185 {
186 case 101:
187 if ((active0 & 0x2000L) != 0L)
188 return jjStartNfaWithStates_0(3, 13, 27);
189 break;
190 case 108:
191 if ((active0 & 0x4000L) != 0L)
192 return jjStartNfaWithStates_0(3, 14, 27);
193 break;
194 case 115:
195 return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
196 default :
197 break;
198 }
199 return jjStartNfa_0(2, active0);
200 }
201 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
202 {
203 if (((active0 &= old0)) == 0L)
204 return jjStartNfa_0(2, old0);
205 try { curChar = input_stream.readChar(); }
206 catch(java.io.IOException e) {
207 jjStopStringLiteralDfa_0(3, active0);
208 return 4;
209 }
210 switch(curChar)
211 {
212 case 101:
213 if ((active0 & 0x8000L) != 0L)
214 return jjStartNfaWithStates_0(4, 15, 27);
215 break;
216 default :
217 break;
218 }
219 return jjStartNfa_0(3, active0);
220 }
221 private int jjStartNfaWithStates_0(int pos, int kind, int state)
222 {
223 jjmatchedKind = kind;
224 jjmatchedPos = pos;
225 try { curChar = input_stream.readChar(); }
226 catch(java.io.IOException e) { return pos + 1; }
227 return jjMoveNfa_0(state, pos + 1);
228 }
229 static final long[] jjbitVec0 = {
230 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
231 };
232 static final long[] jjbitVec2 = {
233 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
234 };
235 static final long[] jjbitVec3 = {
236 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
237 };
238 static final long[] jjbitVec4 = {
239 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
240 };
241 static final long[] jjbitVec5 = {
242 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
243 };
244 static final long[] jjbitVec6 = {
245 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
246 };
247 static final long[] jjbitVec7 = {
248 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
249 };
250 static final long[] jjbitVec8 = {
251 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
252 };
253 private int jjMoveNfa_0(int startState, int curPos)
254 {
255 int startsAt = 0;
256 jjnewStateCnt = 32;
257 int i = 1;
258 jjstateSet[0] = startState;
259 int kind = 0x7fffffff;
260 for (;;)
261 {
262 if (++jjround == 0x7fffffff)
263 ReInitRounds();
264 if (curChar < 64)
265 {
266 long l = 1L << curChar;
267 do
268 {
269 switch(jjstateSet[--i])
270 {
271 case 0:
272 if ((0x3ff000000000000L & l) != 0L)
273 jjCheckNAddTwoStates(3, 4);
274 else if (curChar == 36)
275 {
276 if (kind > 16)
277 kind = 16;
278 jjCheckNAdd(27);
279 }
280 else if (curChar == 34)
281 jjCheckNAddStates(0, 2);
282 else if (curChar == 39)
283 jjAddStates(3, 4);
284 else if (curChar == 46)
285 jjCheckNAdd(7);
286 if ((0x3fe000000000000L & l) != 0L)
287 {
288 if (kind > 6)
289 kind = 6;
290 jjCheckNAddTwoStates(1, 2);
291 }
292 else if (curChar == 48)
293 {
294 if (kind > 6)
295 kind = 6;
296 jjCheckNAddStates(5, 7);
297 }
298 break;
299 case 1:
300 if ((0x3ff000000000000L & l) == 0L)
301 break;
302 if (kind > 6)
303 kind = 6;
304 jjCheckNAddTwoStates(1, 2);
305 break;
306 case 3:
307 if ((0x3ff000000000000L & l) != 0L)
308 jjCheckNAddTwoStates(3, 4);
309 break;
310 case 4:
311 if (curChar != 46)
312 break;
313 if (kind > 10)
314 kind = 10;
315 jjCheckNAdd(5);
316 break;
317 case 5:
318 if ((0x3ff000000000000L & l) == 0L)
319 break;
320 if (kind > 10)
321 kind = 10;
322 jjCheckNAdd(5);
323 break;
324 case 6:
325 if (curChar == 46)
326 jjCheckNAdd(7);
327 break;
328 case 7:
329 if ((0x3ff000000000000L & l) == 0L)
330 break;
331 if (kind > 10)
332 kind = 10;
333 jjCheckNAdd(7);
334 break;
335 case 8:
336 if (curChar == 39)
337 jjAddStates(3, 4);
338 break;
339 case 9:
340 if ((0xffffff7fffffdbffL & l) != 0L)
341 jjCheckNAdd(10);
342 break;
343 case 10:
344 if (curChar == 39 && kind > 11)
345 kind = 11;
346 break;
347 case 12:
348 if ((0x8400000000L & l) != 0L)
349 jjCheckNAdd(10);
350 break;
351 case 13:
352 if ((0xff000000000000L & l) != 0L)
353 jjCheckNAddTwoStates(14, 10);
354 break;
355 case 14:
356 if ((0xff000000000000L & l) != 0L)
357 jjCheckNAdd(10);
358 break;
359 case 15:
360 if ((0xf000000000000L & l) != 0L)
361 jjstateSet[jjnewStateCnt++] = 16;
362 break;
363 case 16:
364 if ((0xff000000000000L & l) != 0L)
365 jjCheckNAdd(14);
366 break;
367 case 17:
368 if (curChar == 34)
369 jjCheckNAddStates(0, 2);
370 break;
371 case 18:
372 if ((0xfffffffbffffdbffL & l) != 0L)
373 jjCheckNAddStates(0, 2);
374 break;
375 case 20:
376 if ((0x8400000000L & l) != 0L)
377 jjCheckNAddStates(0, 2);
378 break;
379 case 21:
380 if (curChar == 34 && kind > 12)
381 kind = 12;
382 break;
383 case 22:
384 if ((0xff000000000000L & l) != 0L)
385 jjCheckNAddStates(8, 11);
386 break;
387 case 23:
388 if ((0xff000000000000L & l) != 0L)
389 jjCheckNAddStates(0, 2);
390 break;
391 case 24:
392 if ((0xf000000000000L & l) != 0L)
393 jjstateSet[jjnewStateCnt++] = 25;
394 break;
395 case 25:
396 if ((0xff000000000000L & l) != 0L)
397 jjCheckNAdd(23);
398 break;
399 case 26:
400 if (curChar != 36)
401 break;
402 if (kind > 16)
403 kind = 16;
404 jjCheckNAdd(27);
405 break;
406 case 27:
407 if ((0x3ff001000000000L & l) == 0L)
408 break;
409 if (kind > 16)
410 kind = 16;
411 jjCheckNAdd(27);
412 break;
413 case 28:
414 if (curChar != 48)
415 break;
416 if (kind > 6)
417 kind = 6;
418 jjCheckNAddStates(5, 7);
419 break;
420 case 30:
421 if ((0x3ff000000000000L & l) == 0L)
422 break;
423 if (kind > 6)
424 kind = 6;
425 jjCheckNAddTwoStates(30, 2);
426 break;
427 case 31:
428 if ((0xff000000000000L & l) == 0L)
429 break;
430 if (kind > 6)
431 kind = 6;
432 jjCheckNAddTwoStates(31, 2);
433 break;
434 default : break;
435 }
436 } while(i != startsAt);
437 }
438 else if (curChar < 128)
439 {
440 long l = 1L << (curChar & 077);
441 do
442 {
443 switch(jjstateSet[--i])
444 {
445 case 0:
446 case 27:
447 if ((0x7fffffe87fffffeL & l) == 0L)
448 break;
449 if (kind > 16)
450 kind = 16;
451 jjCheckNAdd(27);
452 break;
453 case 2:
454 if ((0x100000001000L & l) != 0L && kind > 6)
455 kind = 6;
456 break;
457 case 9:
458 if ((0xffffffffefffffffL & l) != 0L)
459 jjCheckNAdd(10);
460 break;
461 case 11:
462 if (curChar == 92)
463 jjAddStates(12, 14);
464 break;
465 case 12:
466 if ((0x14404410000000L & l) != 0L)
467 jjCheckNAdd(10);
468 break;
469 case 18:
470 if ((0xffffffffefffffffL & l) != 0L)
471 jjCheckNAddStates(0, 2);
472 break;
473 case 19:
474 if (curChar == 92)
475 jjAddStates(15, 17);
476 break;
477 case 20:
478 if ((0x14404410000000L & l) != 0L)
479 jjCheckNAddStates(0, 2);
480 break;
481 case 29:
482 if ((0x100000001000000L & l) != 0L)
483 jjCheckNAdd(30);
484 break;
485 case 30:
486 if ((0x7e0000007eL & l) == 0L)
487 break;
488 if (kind > 6)
489 kind = 6;
490 jjCheckNAddTwoStates(30, 2);
491 break;
492 default : break;
493 }
494 } while(i != startsAt);
495 }
496 else
497 {
498 int hiByte = (int)(curChar >> 8);
499 int i1 = hiByte >> 6;
500 long l1 = 1L << (hiByte & 077);
501 int i2 = (curChar & 0xff) >> 6;
502 long l2 = 1L << (curChar & 077);
503 do
504 {
505 switch(jjstateSet[--i])
506 {
507 case 0:
508 case 27:
509 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
510 break;
511 if (kind > 16)
512 kind = 16;
513 jjCheckNAdd(27);
514 break;
515 case 9:
516 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
517 jjstateSet[jjnewStateCnt++] = 10;
518 break;
519 case 18:
520 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
521 jjAddStates(0, 2);
522 break;
523 default : break;
524 }
525 } while(i != startsAt);
526 }
527 if (kind != 0x7fffffff)
528 {
529 jjmatchedKind = kind;
530 jjmatchedPos = curPos;
531 kind = 0x7fffffff;
532 }
533 ++curPos;
534 if ((i = jjnewStateCnt) == (startsAt = 32 - (jjnewStateCnt = startsAt)))
535 return curPos;
536 try { curChar = input_stream.readChar(); }
537 catch(java.io.IOException e) { return curPos; }
538 }
539 }
540 static final int[] jjnextStates = {
541 18, 19, 21, 9, 11, 29, 31, 2, 18, 19, 23, 21, 12, 13, 15, 20,
542 22, 24,
543 };
544 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
545 {
546 switch(hiByte)
547 {
548 case 0:
549 return ((jjbitVec2[i2] & l2) != 0L);
550 default :
551 if ((jjbitVec0[i1] & l1) != 0L)
552 return true;
553 return false;
554 }
555 }
556 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
557 {
558 switch(hiByte)
559 {
560 case 0:
561 return ((jjbitVec4[i2] & l2) != 0L);
562 case 48:
563 return ((jjbitVec5[i2] & l2) != 0L);
564 case 49:
565 return ((jjbitVec6[i2] & l2) != 0L);
566 case 51:
567 return ((jjbitVec7[i2] & l2) != 0L);
568 case 61:
569 return ((jjbitVec8[i2] & l2) != 0L);
570 default :
571 if ((jjbitVec3[i1] & l1) != 0L)
572 return true;
573 return false;
574 }
575 }
576
577
578 public static final String[] jjstrLiteralImages = {
579 "", null, null, null, null, null, null, null, null, null, null, null, null,
580 "\164\162\165\145", "\156\165\154\154", "\146\141\154\163\145", null, null, null, "\174\174",
581 "\46\46", "\75\75", "\41\75", "\74", "\76", "\74\75", "\76\75", "\53", "\55", "\52",
582 "\57", "\45", "\176", "\41", "\50", "\51", "\56", "\54", };
583
584
585 public static final String[] lexStateNames = {
586 "DEFAULT",
587 };
588 static final long[] jjtoToken = {
589 0x3ffff9fc41L,
590 };
591 static final long[] jjtoSkip = {
592 0x3eL,
593 };
594 protected JavaCharStream input_stream;
595 private final int[] jjrounds = new int[32];
596 private final int[] jjstateSet = new int[64];
597 protected char curChar;
598
599 public ExpressionParserTokenManager(JavaCharStream stream){
600 if (JavaCharStream.staticFlag)
601 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
602 input_stream = stream;
603 }
604
605
606 public ExpressionParserTokenManager(JavaCharStream stream, int lexState){
607 this(stream);
608 SwitchTo(lexState);
609 }
610
611
612 public void ReInit(JavaCharStream stream)
613 {
614 jjmatchedPos = jjnewStateCnt = 0;
615 curLexState = defaultLexState;
616 input_stream = stream;
617 ReInitRounds();
618 }
619 private void ReInitRounds()
620 {
621 int i;
622 jjround = 0x80000001;
623 for (i = 32; i-- > 0;)
624 jjrounds[i] = 0x80000000;
625 }
626
627
628 public void ReInit(JavaCharStream stream, int lexState)
629 {
630 ReInit(stream);
631 SwitchTo(lexState);
632 }
633
634
635 public void SwitchTo(int lexState)
636 {
637 if (lexState >= 1 || lexState < 0)
638 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
639 else
640 curLexState = lexState;
641 }
642
643 protected Token jjFillToken()
644 {
645 final Token t;
646 final String curTokenImage;
647 final int beginLine;
648 final int endLine;
649 final int beginColumn;
650 final int endColumn;
651 String im = jjstrLiteralImages[jjmatchedKind];
652 curTokenImage = (im == null) ? input_stream.GetImage() : im;
653 beginLine = input_stream.getBeginLine();
654 beginColumn = input_stream.getBeginColumn();
655 endLine = input_stream.getEndLine();
656 endColumn = input_stream.getEndColumn();
657 t = Token.newToken(jjmatchedKind, curTokenImage);
658
659 t.beginLine = beginLine;
660 t.endLine = endLine;
661 t.beginColumn = beginColumn;
662 t.endColumn = endColumn;
663
664 return t;
665 }
666
667 int curLexState = 0;
668 int defaultLexState = 0;
669 int jjnewStateCnt;
670 int jjround;
671 int jjmatchedPos;
672 int jjmatchedKind;
673
674
675 public Token getNextToken()
676 {
677 Token matchedToken;
678 int curPos = 0;
679
680 EOFLoop :
681 for (;;)
682 {
683 try
684 {
685 curChar = input_stream.BeginToken();
686 }
687 catch(java.io.IOException e)
688 {
689 jjmatchedKind = 0;
690 matchedToken = jjFillToken();
691 return matchedToken;
692 }
693
694 try { input_stream.backup(0);
695 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
696 curChar = input_stream.BeginToken();
697 }
698 catch (java.io.IOException e1) { continue EOFLoop; }
699 jjmatchedKind = 0x7fffffff;
700 jjmatchedPos = 0;
701 curPos = jjMoveStringLiteralDfa0_0();
702 if (jjmatchedKind != 0x7fffffff)
703 {
704 if (jjmatchedPos + 1 < curPos)
705 input_stream.backup(curPos - jjmatchedPos - 1);
706 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
707 {
708 matchedToken = jjFillToken();
709 return matchedToken;
710 }
711 else
712 {
713 continue EOFLoop;
714 }
715 }
716 int error_line = input_stream.getEndLine();
717 int error_column = input_stream.getEndColumn();
718 String error_after = null;
719 boolean EOFSeen = false;
720 try { input_stream.readChar(); input_stream.backup(1); }
721 catch (java.io.IOException e1) {
722 EOFSeen = true;
723 error_after = curPos <= 1 ? "" : input_stream.GetImage();
724 if (curChar == '\n' || curChar == '\r') {
725 error_line++;
726 error_column = 0;
727 }
728 else
729 error_column++;
730 }
731 if (!EOFSeen) {
732 input_stream.backup(1);
733 error_after = curPos <= 1 ? "" : input_stream.GetImage();
734 }
735 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
736 }
737 }
738
739 private void jjCheckNAdd(int state)
740 {
741 if (jjrounds[state] != jjround)
742 {
743 jjstateSet[jjnewStateCnt++] = state;
744 jjrounds[state] = jjround;
745 }
746 }
747 private void jjAddStates(int start, int end)
748 {
749 do {
750 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
751 } while (start++ != end);
752 }
753 private void jjCheckNAddTwoStates(int state1, int state2)
754 {
755 jjCheckNAdd(state1);
756 jjCheckNAdd(state2);
757 }
758
759 private void jjCheckNAddStates(int start, int end)
760 {
761 do {
762 jjCheckNAdd(jjnextStates[start]);
763 } while (start++ != end);
764 }
765
766 }