001/* Generated By:JavaCC: Do not edit this line. ELParserTokenManager.java */
002package org.apache.commons.el.parser;
003
004public class ELParserTokenManager implements ELParserConstants
005{
006  public  java.io.PrintStream debugStream = System.out;
007  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
008private final int jjStopStringLiteralDfa_0(int pos, long active0)
009{
010   switch (pos)
011   {
012      case 0:
013         if ((active0 & 0x4L) != 0L)
014         {
015            jjmatchedKind = 1;
016            return 2;
017         }
018         return -1;
019      default :
020         return -1;
021   }
022}
023private final int jjStartNfa_0(int pos, long active0)
024{
025   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
026}
027private final int jjStopAtPos(int pos, int kind)
028{
029   jjmatchedKind = kind;
030   jjmatchedPos = pos;
031   return pos + 1;
032}
033private final int jjStartNfaWithStates_0(int pos, int kind, int state)
034{
035   jjmatchedKind = kind;
036   jjmatchedPos = pos;
037   try { curChar = input_stream.readChar(); }
038   catch(java.io.IOException e) { return pos + 1; }
039   return jjMoveNfa_0(state, pos + 1);
040}
041private final int jjMoveStringLiteralDfa0_0()
042{
043   switch(curChar)
044   {
045      case 36:
046         return jjMoveStringLiteralDfa1_0(0x4L);
047      default :
048         return jjMoveNfa_0(1, 0);
049   }
050}
051private final int jjMoveStringLiteralDfa1_0(long active0)
052{
053   try { curChar = input_stream.readChar(); }
054   catch(java.io.IOException e) {
055      jjStopStringLiteralDfa_0(0, active0);
056      return 1;
057   }
058   switch(curChar)
059   {
060      case 123:
061         if ((active0 & 0x4L) != 0L)
062            return jjStopAtPos(1, 2);
063         break;
064      default :
065         break;
066   }
067   return jjStartNfa_0(0, active0);
068}
069private final void jjCheckNAdd(int state)
070{
071   if (jjrounds[state] != jjround)
072   {
073      jjstateSet[jjnewStateCnt++] = state;
074      jjrounds[state] = jjround;
075   }
076}
077private final void jjAddStates(int start, int end)
078{
079   do {
080      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
081   } while (start++ != end);
082}
083private final void jjCheckNAddTwoStates(int state1, int state2)
084{
085   jjCheckNAdd(state1);
086   jjCheckNAdd(state2);
087}
088private final void jjCheckNAddStates(int start, int end)
089{
090   do {
091      jjCheckNAdd(jjnextStates[start]);
092   } while (start++ != end);
093}
094private final void jjCheckNAddStates(int start)
095{
096   jjCheckNAdd(jjnextStates[start]);
097   jjCheckNAdd(jjnextStates[start + 1]);
098}
099static final long[] jjbitVec0 = {
100   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
101};
102static final long[] jjbitVec2 = {
103   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
104};
105private final int jjMoveNfa_0(int startState, int curPos)
106{
107   int[] nextStates;
108   int startsAt = 0;
109   jjnewStateCnt = 3;
110   int i = 1;
111   jjstateSet[0] = startState;
112   int j, kind = 0x7fffffff;
113   for (;;)
114   {
115      if (++jjround == 0x7fffffff)
116         ReInitRounds();
117      if (curChar < 64)
118      {
119         long l = 1L << curChar;
120         MatchLoop: do
121         {
122            switch(jjstateSet[--i])
123            {
124               case 1:
125                  if ((0xffffffefffffffffL & l) != 0L)
126                  {
127                     if (kind > 1)
128                        kind = 1;
129                     jjCheckNAdd(0);
130                  }
131                  else if (curChar == 36)
132                  {
133                     if (kind > 1)
134                        kind = 1;
135                     jjCheckNAdd(2);
136                  }
137                  break;
138               case 0:
139                  if ((0xffffffefffffffffL & l) == 0L)
140                     break;
141                  if (kind > 1)
142                     kind = 1;
143                  jjCheckNAdd(0);
144                  break;
145               case 2:
146                  if ((0xffffffefffffffffL & l) == 0L)
147                     break;
148                  if (kind > 1)
149                     kind = 1;
150                  jjCheckNAdd(2);
151                  break;
152               default : break;
153            }
154         } while(i != startsAt);
155      }
156      else if (curChar < 128)
157      {
158         long l = 1L << (curChar & 077);
159         MatchLoop: do
160         {
161            switch(jjstateSet[--i])
162            {
163               case 1:
164               case 0:
165                  if (kind > 1)
166                     kind = 1;
167                  jjCheckNAdd(0);
168                  break;
169               case 2:
170                  if ((0xf7ffffffffffffffL & l) == 0L)
171                     break;
172                  if (kind > 1)
173                     kind = 1;
174                  jjstateSet[jjnewStateCnt++] = 2;
175                  break;
176               default : break;
177            }
178         } while(i != startsAt);
179      }
180      else
181      {
182         int hiByte = (int)(curChar >> 8);
183         int i1 = hiByte >> 6;
184         long l1 = 1L << (hiByte & 077);
185         int i2 = (curChar & 0xff) >> 6;
186         long l2 = 1L << (curChar & 077);
187         MatchLoop: do
188         {
189            switch(jjstateSet[--i])
190            {
191               case 1:
192               case 0:
193                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
194                     break;
195                  if (kind > 1)
196                     kind = 1;
197                  jjCheckNAdd(0);
198                  break;
199               case 2:
200                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
201                     break;
202                  if (kind > 1)
203                     kind = 1;
204                  jjstateSet[jjnewStateCnt++] = 2;
205                  break;
206               default : break;
207            }
208         } while(i != startsAt);
209      }
210      if (kind != 0x7fffffff)
211      {
212         jjmatchedKind = kind;
213         jjmatchedPos = curPos;
214         kind = 0x7fffffff;
215      }
216      ++curPos;
217      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
218         return curPos;
219      try { curChar = input_stream.readChar(); }
220      catch(java.io.IOException e) { return curPos; }
221   }
222}
223private final int jjStopStringLiteralDfa_1(int pos, long active0)
224{
225   switch (pos)
226   {
227      case 0:
228         if ((active0 & 0x10000L) != 0L)
229            return 1;
230         if ((active0 & 0x1568015547000L) != 0L)
231         {
232            jjmatchedKind = 50;
233            return 6;
234         }
235         return -1;
236      case 1:
237         if ((active0 & 0x400015540000L) != 0L)
238            return 6;
239         if ((active0 & 0x1168000007000L) != 0L)
240         {
241            jjmatchedKind = 50;
242            jjmatchedPos = 1;
243            return 6;
244         }
245         return -1;
246      case 2:
247         if ((active0 & 0x168000000000L) != 0L)
248            return 6;
249         if ((active0 & 0x1000000007000L) != 0L)
250         {
251            jjmatchedKind = 50;
252            jjmatchedPos = 2;
253            return 6;
254         }
255         return -1;
256      case 3:
257         if ((active0 & 0x1000000002000L) != 0L)
258         {
259            jjmatchedKind = 50;
260            jjmatchedPos = 3;
261            return 6;
262         }
263         if ((active0 & 0x5000L) != 0L)
264            return 6;
265         return -1;
266      default :
267         return -1;
268   }
269}
270private final int jjStartNfa_1(int pos, long active0)
271{
272   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
273}
274private final int jjStartNfaWithStates_1(int pos, int kind, int state)
275{
276   jjmatchedKind = kind;
277   jjmatchedPos = pos;
278   try { curChar = input_stream.readChar(); }
279   catch(java.io.IOException e) { return pos + 1; }
280   return jjMoveNfa_1(state, pos + 1);
281}
282private final int jjMoveStringLiteralDfa0_1()
283{
284   switch(curChar)
285   {
286      case 33:
287         jjmatchedKind = 43;
288         return jjMoveStringLiteralDfa1_1(0x8000000L);
289      case 37:
290         return jjStopAtPos(0, 40);
291      case 38:
292         return jjMoveStringLiteralDfa1_1(0x200000000000L);
293      case 40:
294         return jjStopAtPos(0, 29);
295      case 41:
296         return jjStopAtPos(0, 30);
297      case 42:
298         return jjStopAtPos(0, 37);
299      case 43:
300         return jjStopAtPos(0, 35);
301      case 44:
302         return jjStopAtPos(0, 31);
303      case 45:
304         return jjStopAtPos(0, 36);
305      case 46:
306         return jjStartNfaWithStates_1(0, 16, 1);
307      case 47:
308         return jjStopAtPos(0, 38);
309      case 58:
310         return jjStopAtPos(0, 32);
311      case 60:
312         jjmatchedKind = 19;
313         return jjMoveStringLiteralDfa1_1(0x800000L);
314      case 61:
315         return jjMoveStringLiteralDfa1_1(0x200000L);
316      case 62:
317         jjmatchedKind = 17;
318         return jjMoveStringLiteralDfa1_1(0x2000000L);
319      case 63:
320         return jjStopAtPos(0, 49);
321      case 91:
322         return jjStopAtPos(0, 33);
323      case 93:
324         return jjStopAtPos(0, 34);
325      case 97:
326         return jjMoveStringLiteralDfa1_1(0x100000000000L);
327      case 100:
328         return jjMoveStringLiteralDfa1_1(0x8000000000L);
329      case 101:
330         return jjMoveStringLiteralDfa1_1(0x1000000400000L);
331      case 102:
332         return jjMoveStringLiteralDfa1_1(0x2000L);
333      case 103:
334         return jjMoveStringLiteralDfa1_1(0x4040000L);
335      case 108:
336         return jjMoveStringLiteralDfa1_1(0x1100000L);
337      case 109:
338         return jjMoveStringLiteralDfa1_1(0x20000000000L);
339      case 110:
340         return jjMoveStringLiteralDfa1_1(0x40010004000L);
341      case 111:
342         return jjMoveStringLiteralDfa1_1(0x400000000000L);
343      case 116:
344         return jjMoveStringLiteralDfa1_1(0x1000L);
345      case 124:
346         return jjMoveStringLiteralDfa1_1(0x800000000000L);
347      case 125:
348         return jjStopAtPos(0, 15);
349      default :
350         return jjMoveNfa_1(0, 0);
351   }
352}
353private final int jjMoveStringLiteralDfa1_1(long active0)
354{
355   try { curChar = input_stream.readChar(); }
356   catch(java.io.IOException e) {
357      jjStopStringLiteralDfa_1(0, active0);
358      return 1;
359   }
360   switch(curChar)
361   {
362      case 38:
363         if ((active0 & 0x200000000000L) != 0L)
364            return jjStopAtPos(1, 45);
365         break;
366      case 61:
367         if ((active0 & 0x200000L) != 0L)
368            return jjStopAtPos(1, 21);
369         else if ((active0 & 0x800000L) != 0L)
370            return jjStopAtPos(1, 23);
371         else if ((active0 & 0x2000000L) != 0L)
372            return jjStopAtPos(1, 25);
373         else if ((active0 & 0x8000000L) != 0L)
374            return jjStopAtPos(1, 27);
375         break;
376      case 97:
377         return jjMoveStringLiteralDfa2_1(active0, 0x2000L);
378      case 101:
379         if ((active0 & 0x1000000L) != 0L)
380            return jjStartNfaWithStates_1(1, 24, 6);
381         else if ((active0 & 0x4000000L) != 0L)
382            return jjStartNfaWithStates_1(1, 26, 6);
383         else if ((active0 & 0x10000000L) != 0L)
384            return jjStartNfaWithStates_1(1, 28, 6);
385         break;
386      case 105:
387         return jjMoveStringLiteralDfa2_1(active0, 0x8000000000L);
388      case 109:
389         return jjMoveStringLiteralDfa2_1(active0, 0x1000000000000L);
390      case 110:
391         return jjMoveStringLiteralDfa2_1(active0, 0x100000000000L);
392      case 111:
393         return jjMoveStringLiteralDfa2_1(active0, 0x60000000000L);
394      case 113:
395         if ((active0 & 0x400000L) != 0L)
396            return jjStartNfaWithStates_1(1, 22, 6);
397         break;
398      case 114:
399         if ((active0 & 0x400000000000L) != 0L)
400            return jjStartNfaWithStates_1(1, 46, 6);
401         return jjMoveStringLiteralDfa2_1(active0, 0x1000L);
402      case 116:
403         if ((active0 & 0x40000L) != 0L)
404            return jjStartNfaWithStates_1(1, 18, 6);
405         else if ((active0 & 0x100000L) != 0L)
406            return jjStartNfaWithStates_1(1, 20, 6);
407         break;
408      case 117:
409         return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
410      case 124:
411         if ((active0 & 0x800000000000L) != 0L)
412            return jjStopAtPos(1, 47);
413         break;
414      default :
415         break;
416   }
417   return jjStartNfa_1(0, active0);
418}
419private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
420{
421   if (((active0 &= old0)) == 0L)
422      return jjStartNfa_1(0, old0); 
423   try { curChar = input_stream.readChar(); }
424   catch(java.io.IOException e) {
425      jjStopStringLiteralDfa_1(1, active0);
426      return 2;
427   }
428   switch(curChar)
429   {
430      case 100:
431         if ((active0 & 0x20000000000L) != 0L)
432            return jjStartNfaWithStates_1(2, 41, 6);
433         else if ((active0 & 0x100000000000L) != 0L)
434            return jjStartNfaWithStates_1(2, 44, 6);
435         break;
436      case 108:
437         return jjMoveStringLiteralDfa3_1(active0, 0x6000L);
438      case 112:
439         return jjMoveStringLiteralDfa3_1(active0, 0x1000000000000L);
440      case 116:
441         if ((active0 & 0x40000000000L) != 0L)
442            return jjStartNfaWithStates_1(2, 42, 6);
443         break;
444      case 117:
445         return jjMoveStringLiteralDfa3_1(active0, 0x1000L);
446      case 118:
447         if ((active0 & 0x8000000000L) != 0L)
448            return jjStartNfaWithStates_1(2, 39, 6);
449         break;
450      default :
451         break;
452   }
453   return jjStartNfa_1(1, active0);
454}
455private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
456{
457   if (((active0 &= old0)) == 0L)
458      return jjStartNfa_1(1, old0); 
459   try { curChar = input_stream.readChar(); }
460   catch(java.io.IOException e) {
461      jjStopStringLiteralDfa_1(2, active0);
462      return 3;
463   }
464   switch(curChar)
465   {
466      case 101:
467         if ((active0 & 0x1000L) != 0L)
468            return jjStartNfaWithStates_1(3, 12, 6);
469         break;
470      case 108:
471         if ((active0 & 0x4000L) != 0L)
472            return jjStartNfaWithStates_1(3, 14, 6);
473         break;
474      case 115:
475         return jjMoveStringLiteralDfa4_1(active0, 0x2000L);
476      case 116:
477         return jjMoveStringLiteralDfa4_1(active0, 0x1000000000000L);
478      default :
479         break;
480   }
481   return jjStartNfa_1(2, active0);
482}
483private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
484{
485   if (((active0 &= old0)) == 0L)
486      return jjStartNfa_1(2, old0); 
487   try { curChar = input_stream.readChar(); }
488   catch(java.io.IOException e) {
489      jjStopStringLiteralDfa_1(3, active0);
490      return 4;
491   }
492   switch(curChar)
493   {
494      case 101:
495         if ((active0 & 0x2000L) != 0L)
496            return jjStartNfaWithStates_1(4, 13, 6);
497         break;
498      case 121:
499         if ((active0 & 0x1000000000000L) != 0L)
500            return jjStartNfaWithStates_1(4, 48, 6);
501         break;
502      default :
503         break;
504   }
505   return jjStartNfa_1(3, active0);
506}
507static final long[] jjbitVec3 = {
508   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
509};
510static final long[] jjbitVec4 = {
511   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
512};
513static final long[] jjbitVec5 = {
514   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
515};
516static final long[] jjbitVec6 = {
517   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
518};
519static final long[] jjbitVec7 = {
520   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
521};
522static final long[] jjbitVec8 = {
523   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
524};
525private final int jjMoveNfa_1(int startState, int curPos)
526{
527   int[] nextStates;
528   int startsAt = 0;
529   jjnewStateCnt = 35;
530   int i = 1;
531   jjstateSet[0] = startState;
532   int j, kind = 0x7fffffff;
533   for (;;)
534   {
535      if (++jjround == 0x7fffffff)
536         ReInitRounds();
537      if (curChar < 64)
538      {
539         long l = 1L << curChar;
540         MatchLoop: do
541         {
542            switch(jjstateSet[--i])
543            {
544               case 0:
545                  if ((0x3ff000000000000L & l) != 0L)
546                  {
547                     if (kind > 7)
548                        kind = 7;
549                     jjCheckNAddStates(0, 4);
550                  }
551                  else if ((0x1800000000L & l) != 0L)
552                  {
553                     if (kind > 50)
554                        kind = 50;
555                     jjCheckNAdd(6);
556                  }
557                  else if (curChar == 39)
558                     jjCheckNAddStates(5, 9);
559                  else if (curChar == 34)
560                     jjCheckNAddStates(10, 14);
561                  else if (curChar == 46)
562                     jjCheckNAdd(1);
563                  break;
564               case 1:
565                  if ((0x3ff000000000000L & l) == 0L)
566                     break;
567                  if (kind > 8)
568                     kind = 8;
569                  jjCheckNAddTwoStates(1, 2);
570                  break;
571               case 3:
572                  if ((0x280000000000L & l) != 0L)
573                     jjCheckNAdd(4);
574                  break;
575               case 4:
576                  if ((0x3ff000000000000L & l) == 0L)
577                     break;
578                  if (kind > 8)
579                     kind = 8;
580                  jjCheckNAdd(4);
581                  break;
582               case 5:
583                  if ((0x1800000000L & l) == 0L)
584                     break;
585                  if (kind > 50)
586                     kind = 50;
587                  jjCheckNAdd(6);
588                  break;
589               case 6:
590                  if ((0x3ff001000000000L & l) == 0L)
591                     break;
592                  if (kind > 50)
593                     kind = 50;
594                  jjCheckNAdd(6);
595                  break;
596               case 7:
597                  if ((0x3ff000000000000L & l) == 0L)
598                     break;
599                  if (kind > 7)
600                     kind = 7;
601                  jjCheckNAddStates(0, 4);
602                  break;
603               case 8:
604                  if ((0x3ff000000000000L & l) == 0L)
605                     break;
606                  if (kind > 7)
607                     kind = 7;
608                  jjCheckNAdd(8);
609                  break;
610               case 9:
611                  if ((0x3ff000000000000L & l) != 0L)
612                     jjCheckNAddTwoStates(9, 10);
613                  break;
614               case 10:
615                  if (curChar != 46)
616                     break;
617                  if (kind > 8)
618                     kind = 8;
619                  jjCheckNAddTwoStates(11, 12);
620                  break;
621               case 11:
622                  if ((0x3ff000000000000L & l) == 0L)
623                     break;
624                  if (kind > 8)
625                     kind = 8;
626                  jjCheckNAddTwoStates(11, 12);
627                  break;
628               case 13:
629                  if ((0x280000000000L & l) != 0L)
630                     jjCheckNAdd(14);
631                  break;
632               case 14:
633                  if ((0x3ff000000000000L & l) == 0L)
634                     break;
635                  if (kind > 8)
636                     kind = 8;
637                  jjCheckNAdd(14);
638                  break;
639               case 15:
640                  if ((0x3ff000000000000L & l) != 0L)
641                     jjCheckNAddTwoStates(15, 16);
642                  break;
643               case 17:
644                  if ((0x280000000000L & l) != 0L)
645                     jjCheckNAdd(18);
646                  break;
647               case 18:
648                  if ((0x3ff000000000000L & l) == 0L)
649                     break;
650                  if (kind > 8)
651                     kind = 8;
652                  jjCheckNAdd(18);
653                  break;
654               case 19:
655                  if (curChar == 34)
656                     jjCheckNAddStates(10, 14);
657                  break;
658               case 20:
659                  if ((0xfffffffbffffffffL & l) != 0L)
660                     jjCheckNAddStates(15, 17);
661                  break;
662               case 22:
663                  if (curChar == 34)
664                     jjCheckNAddStates(15, 17);
665                  break;
666               case 23:
667                  if (curChar == 34 && kind > 10)
668                     kind = 10;
669                  break;
670               case 24:
671                  if ((0xfffffffbffffffffL & l) != 0L)
672                     jjCheckNAddTwoStates(24, 25);
673                  break;
674               case 26:
675                  if ((0xfffffffbffffffffL & l) != 0L && kind > 11)
676                     kind = 11;
677                  break;
678               case 27:
679                  if (curChar == 39)
680                     jjCheckNAddStates(5, 9);
681                  break;
682               case 28:
683                  if ((0xffffff7fffffffffL & l) != 0L)
684                     jjCheckNAddStates(18, 20);
685                  break;
686               case 30:
687                  if (curChar == 39)
688                     jjCheckNAddStates(18, 20);
689                  break;
690               case 31:
691                  if (curChar == 39 && kind > 10)
692                     kind = 10;
693                  break;
694               case 32:
695                  if ((0xffffff7fffffffffL & l) != 0L)
696                     jjCheckNAddTwoStates(32, 33);
697                  break;
698               case 34:
699                  if ((0xffffff7fffffffffL & l) != 0L && kind > 11)
700                     kind = 11;
701                  break;
702               default : break;
703            }
704         } while(i != startsAt);
705      }
706      else if (curChar < 128)
707      {
708         long l = 1L << (curChar & 077);
709         MatchLoop: do
710         {
711            switch(jjstateSet[--i])
712            {
713               case 0:
714               case 6:
715                  if ((0x7fffffe87fffffeL & l) == 0L)
716                     break;
717                  if (kind > 50)
718                     kind = 50;
719                  jjCheckNAdd(6);
720                  break;
721               case 2:
722                  if ((0x2000000020L & l) != 0L)
723                     jjAddStates(21, 22);
724                  break;
725               case 12:
726                  if ((0x2000000020L & l) != 0L)
727                     jjAddStates(23, 24);
728                  break;
729               case 16:
730                  if ((0x2000000020L & l) != 0L)
731                     jjAddStates(25, 26);
732                  break;
733               case 20:
734                  if ((0xffffffffefffffffL & l) != 0L)
735                     jjCheckNAddStates(15, 17);
736                  break;
737               case 21:
738                  if (curChar == 92)
739                     jjstateSet[jjnewStateCnt++] = 22;
740                  break;
741               case 22:
742                  if (curChar == 92)
743                     jjCheckNAddStates(15, 17);
744                  break;
745               case 24:
746                  if ((0xffffffffefffffffL & l) != 0L)
747                     jjAddStates(27, 28);
748                  break;
749               case 25:
750                  if (curChar == 92)
751                     jjstateSet[jjnewStateCnt++] = 26;
752                  break;
753               case 26:
754               case 34:
755                  if ((0xffffffffefffffffL & l) != 0L && kind > 11)
756                     kind = 11;
757                  break;
758               case 28:
759                  if ((0xffffffffefffffffL & l) != 0L)
760                     jjCheckNAddStates(18, 20);
761                  break;
762               case 29:
763                  if (curChar == 92)
764                     jjstateSet[jjnewStateCnt++] = 30;
765                  break;
766               case 30:
767                  if (curChar == 92)
768                     jjCheckNAddStates(18, 20);
769                  break;
770               case 32:
771                  if ((0xffffffffefffffffL & l) != 0L)
772                     jjAddStates(29, 30);
773                  break;
774               case 33:
775                  if (curChar == 92)
776                     jjstateSet[jjnewStateCnt++] = 34;
777                  break;
778               default : break;
779            }
780         } while(i != startsAt);
781      }
782      else
783      {
784         int hiByte = (int)(curChar >> 8);
785         int i1 = hiByte >> 6;
786         long l1 = 1L << (hiByte & 077);
787         int i2 = (curChar & 0xff) >> 6;
788         long l2 = 1L << (curChar & 077);
789         MatchLoop: do
790         {
791            switch(jjstateSet[--i])
792            {
793               case 0:
794               case 6:
795                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
796                     break;
797                  if (kind > 50)
798                     kind = 50;
799                  jjCheckNAdd(6);
800                  break;
801               case 20:
802                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
803                     jjAddStates(15, 17);
804                  break;
805               case 24:
806                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
807                     jjAddStates(27, 28);
808                  break;
809               case 26:
810               case 34:
811                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 11)
812                     kind = 11;
813                  break;
814               case 28:
815                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
816                     jjAddStates(18, 20);
817                  break;
818               case 32:
819                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
820                     jjAddStates(29, 30);
821                  break;
822               default : break;
823            }
824         } while(i != startsAt);
825      }
826      if (kind != 0x7fffffff)
827      {
828         jjmatchedKind = kind;
829         jjmatchedPos = curPos;
830         kind = 0x7fffffff;
831      }
832      ++curPos;
833      if ((i = jjnewStateCnt) == (startsAt = 35 - (jjnewStateCnt = startsAt)))
834         return curPos;
835      try { curChar = input_stream.readChar(); }
836      catch(java.io.IOException e) { return curPos; }
837   }
838}
839static final int[] jjnextStates = {
840   8, 9, 10, 15, 16, 28, 29, 31, 32, 33, 20, 21, 23, 24, 25, 20, 
841   21, 23, 28, 29, 31, 3, 4, 13, 14, 17, 18, 24, 25, 32, 33, 
842};
843private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
844{
845   switch(hiByte)
846   {
847      case 0:
848         return ((jjbitVec2[i2] & l2) != 0L);
849      default : 
850         if ((jjbitVec0[i1] & l1) != 0L)
851            return true;
852         return false;
853   }
854}
855private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
856{
857   switch(hiByte)
858   {
859      case 0:
860         return ((jjbitVec4[i2] & l2) != 0L);
861      case 48:
862         return ((jjbitVec5[i2] & l2) != 0L);
863      case 49:
864         return ((jjbitVec6[i2] & l2) != 0L);
865      case 51:
866         return ((jjbitVec7[i2] & l2) != 0L);
867      case 61:
868         return ((jjbitVec8[i2] & l2) != 0L);
869      default : 
870         if ((jjbitVec3[i1] & l1) != 0L)
871            return true;
872         return false;
873   }
874}
875public static final String[] jjstrLiteralImages = {
876"", null, "\44\173", null, null, null, null, null, null, null, null, null, 
877"\164\162\165\145", "\146\141\154\163\145", "\156\165\154\154", "\175", "\56", "\76", "\147\164", 
878"\74", "\154\164", "\75\75", "\145\161", "\74\75", "\154\145", "\76\75", "\147\145", 
879"\41\75", "\156\145", "\50", "\51", "\54", "\72", "\133", "\135", "\53", "\55", "\52", 
880"\57", "\144\151\166", "\45", "\155\157\144", "\156\157\164", "\41", "\141\156\144", 
881"\46\46", "\157\162", "\174\174", "\145\155\160\164\171", "\77", null, null, null, null, 
882null, };
883public static final String[] lexStateNames = {
884   "DEFAULT", 
885   "IN_EXPRESSION", 
886};
887public static final int[] jjnewLexState = {
888   -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
889   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
890   -1, -1, -1, -1, -1, 
891};
892static final long[] jjtoToken = {
893   0x47fffffffffd87L, 
894};
895static final long[] jjtoSkip = {
896   0x78L, 
897};
898private SimpleCharStream input_stream;
899private final int[] jjrounds = new int[35];
900private final int[] jjstateSet = new int[70];
901protected char curChar;
902public ELParserTokenManager(SimpleCharStream stream)
903{
904   if (SimpleCharStream.staticFlag)
905      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
906   input_stream = stream;
907}
908public ELParserTokenManager(SimpleCharStream stream, int lexState)
909{
910   this(stream);
911   SwitchTo(lexState);
912}
913public void ReInit(SimpleCharStream stream)
914{
915   jjmatchedPos = jjnewStateCnt = 0;
916   curLexState = defaultLexState;
917   input_stream = stream;
918   ReInitRounds();
919}
920private final void ReInitRounds()
921{
922   int i;
923   jjround = 0x80000001;
924   for (i = 35; i-- > 0;)
925      jjrounds[i] = 0x80000000;
926}
927public void ReInit(SimpleCharStream stream, int lexState)
928{
929   ReInit(stream);
930   SwitchTo(lexState);
931}
932public void SwitchTo(int lexState)
933{
934   if (lexState >= 2 || lexState < 0)
935      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
936   else
937      curLexState = lexState;
938}
939
940private final Token jjFillToken()
941{
942   Token t = Token.newToken(jjmatchedKind);
943   t.kind = jjmatchedKind;
944   String im = jjstrLiteralImages[jjmatchedKind];
945   t.image = (im == null) ? input_stream.GetImage() : im;
946   t.beginLine = input_stream.getBeginLine();
947   t.beginColumn = input_stream.getBeginColumn();
948   t.endLine = input_stream.getEndLine();
949   t.endColumn = input_stream.getEndColumn();
950   return t;
951}
952
953int curLexState = 0;
954int defaultLexState = 0;
955int jjnewStateCnt;
956int jjround;
957int jjmatchedPos;
958int jjmatchedKind;
959
960public final Token getNextToken() 
961{
962  int kind;
963  Token specialToken = null;
964  Token matchedToken;
965  int curPos = 0;
966
967  EOFLoop :
968  for (;;)
969  {   
970   try   
971   {     
972      curChar = input_stream.BeginToken();
973   }     
974   catch(java.io.IOException e)
975   {        
976      jjmatchedKind = 0;
977      matchedToken = jjFillToken();
978      return matchedToken;
979   }
980
981   switch(curLexState)
982   {
983     case 0:
984       jjmatchedKind = 0x7fffffff;
985       jjmatchedPos = 0;
986       curPos = jjMoveStringLiteralDfa0_0();
987       break;
988     case 1:
989       try { input_stream.backup(0);
990          while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
991             curChar = input_stream.BeginToken();
992       }
993       catch (java.io.IOException e1) { continue EOFLoop; }
994       jjmatchedKind = 0x7fffffff;
995       jjmatchedPos = 0;
996       curPos = jjMoveStringLiteralDfa0_1();
997       if (jjmatchedPos == 0 && jjmatchedKind > 54)
998       {
999          jjmatchedKind = 54;
1000       }
1001       break;
1002   }
1003     if (jjmatchedKind != 0x7fffffff)
1004     {
1005        if (jjmatchedPos + 1 < curPos)
1006           input_stream.backup(curPos - jjmatchedPos - 1);
1007        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1008        {
1009           matchedToken = jjFillToken();
1010       if (jjnewLexState[jjmatchedKind] != -1)
1011         curLexState = jjnewLexState[jjmatchedKind];
1012           return matchedToken;
1013        }
1014        else
1015        {
1016         if (jjnewLexState[jjmatchedKind] != -1)
1017           curLexState = jjnewLexState[jjmatchedKind];
1018           continue EOFLoop;
1019        }
1020     }
1021     int error_line = input_stream.getEndLine();
1022     int error_column = input_stream.getEndColumn();
1023     String error_after = null;
1024     boolean EOFSeen = false;
1025     try { input_stream.readChar(); input_stream.backup(1); }
1026     catch (java.io.IOException e1) {
1027        EOFSeen = true;
1028        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1029        if (curChar == '\n' || curChar == '\r') {
1030           error_line++;
1031           error_column = 0;
1032        }
1033        else
1034           error_column++;
1035     }
1036     if (!EOFSeen) {
1037        input_stream.backup(1);
1038        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1039     }
1040     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1041  }
1042}
1043
1044}