001/* Generated By:JavaCC: Do not edit this line. ExpressionParserTokenManager.java */
002package com.randomnoun.common.jexl.parser;
003import java.io.*;
004import com.randomnoun.common.jexl.ast.*;
005import java.util.Vector;
006
007/** Token Manager. */
008public class ExpressionParserTokenManager implements ExpressionParserConstants
009{
010
011  /** Debug output. */
012  public  java.io.PrintStream debugStream = System.out;
013  /** Set debug output. */
014  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
015private final int jjStopStringLiteralDfa_0(int pos, long active0)
016{
017   switch (pos)
018   {
019      case 0:
020         if ((active0 & 0xe000L) != 0L)
021         {
022            jjmatchedKind = 16;
023            return 27;
024         }
025         if ((active0 & 0x1000000000L) != 0L)
026            return 7;
027         return -1;
028      case 1:
029         if ((active0 & 0xe000L) != 0L)
030         {
031            jjmatchedKind = 16;
032            jjmatchedPos = 1;
033            return 27;
034         }
035         return -1;
036      case 2:
037         if ((active0 & 0xe000L) != 0L)
038         {
039            jjmatchedKind = 16;
040            jjmatchedPos = 2;
041            return 27;
042         }
043         return -1;
044      case 3:
045         if ((active0 & 0x8000L) != 0L)
046         {
047            jjmatchedKind = 16;
048            jjmatchedPos = 3;
049            return 27;
050         }
051         if ((active0 & 0x6000L) != 0L)
052            return 27;
053         return -1;
054      default :
055         return -1;
056   }
057}
058private final int jjStartNfa_0(int pos, long active0)
059{
060   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
061}
062private int jjStopAtPos(int pos, int kind)
063{
064   jjmatchedKind = kind;
065   jjmatchedPos = pos;
066   return pos + 1;
067}
068private int jjMoveStringLiteralDfa0_0()
069{
070   switch(curChar)
071   {
072      case 33:
073         jjmatchedKind = 33;
074         return jjMoveStringLiteralDfa1_0(0x400000L);
075      case 37:
076         return jjStopAtPos(0, 31);
077      case 38:
078         return jjMoveStringLiteralDfa1_0(0x100000L);
079      case 40:
080         return jjStopAtPos(0, 34);
081      case 41:
082         return jjStopAtPos(0, 35);
083      case 42:
084         return jjStopAtPos(0, 29);
085      case 43:
086         return jjStopAtPos(0, 27);
087      case 44:
088         return jjStopAtPos(0, 37);
089      case 45:
090         return jjStopAtPos(0, 28);
091      case 46:
092         return jjStartNfaWithStates_0(0, 36, 7);
093      case 47:
094         return jjStopAtPos(0, 30);
095      case 60:
096         jjmatchedKind = 23;
097         return jjMoveStringLiteralDfa1_0(0x2000000L);
098      case 61:
099         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}
117private 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}
155private 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}
175private 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}
201private 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}
221private 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}
229static final long[] jjbitVec0 = {
230   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
231};
232static final long[] jjbitVec2 = {
233   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
234};
235static final long[] jjbitVec3 = {
236   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
237};
238static final long[] jjbitVec4 = {
239   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
240};
241static final long[] jjbitVec5 = {
242   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
243};
244static final long[] jjbitVec6 = {
245   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
246};
247static final long[] jjbitVec7 = {
248   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
249};
250static final long[] jjbitVec8 = {
251   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
252};
253private 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}
540static final int[] jjnextStates = {
541   18, 19, 21, 9, 11, 29, 31, 2, 18, 19, 23, 21, 12, 13, 15, 20, 
542   22, 24, 
543};
544private 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}
556private 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/** Token literal values. */
578public 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/** Lexer state names. */
585public static final String[] lexStateNames = {
586   "DEFAULT",
587};
588static final long[] jjtoToken = {
589   0x3ffff9fc41L, 
590};
591static final long[] jjtoSkip = {
592   0x3eL, 
593};
594protected JavaCharStream input_stream;
595private final int[] jjrounds = new int[32];
596private final int[] jjstateSet = new int[64];
597protected char curChar;
598/** Constructor. */
599public 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/** Constructor. */
606public ExpressionParserTokenManager(JavaCharStream stream, int lexState){
607   this(stream);
608   SwitchTo(lexState);
609}
610
611/** Reinitialise parser. */
612public void ReInit(JavaCharStream stream)
613{
614   jjmatchedPos = jjnewStateCnt = 0;
615   curLexState = defaultLexState;
616   input_stream = stream;
617   ReInitRounds();
618}
619private void ReInitRounds()
620{
621   int i;
622   jjround = 0x80000001;
623   for (i = 32; i-- > 0;)
624      jjrounds[i] = 0x80000000;
625}
626
627/** Reinitialise parser. */
628public void ReInit(JavaCharStream stream, int lexState)
629{
630   ReInit(stream);
631   SwitchTo(lexState);
632}
633
634/** Switch to specified lex state. */
635public 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
643protected 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
667int curLexState = 0;
668int defaultLexState = 0;
669int jjnewStateCnt;
670int jjround;
671int jjmatchedPos;
672int jjmatchedKind;
673
674/** Get the next Token. */
675public 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
739private void jjCheckNAdd(int state)
740{
741   if (jjrounds[state] != jjround)
742   {
743      jjstateSet[jjnewStateCnt++] = state;
744      jjrounds[state] = jjround;
745   }
746}
747private void jjAddStates(int start, int end)
748{
749   do {
750      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
751   } while (start++ != end);
752}
753private void jjCheckNAddTwoStates(int state1, int state2)
754{
755   jjCheckNAdd(state1);
756   jjCheckNAdd(state2);
757}
758
759private void jjCheckNAddStates(int start, int end)
760{
761   do {
762      jjCheckNAdd(jjnextStates[start]);
763   } while (start++ != end);
764}
765
766}