001    /* Generated By:JavaCC: Do not edit this line. ELParserTokenManager.java */
002    package org.apache.commons.el.parser;
003    
004    public class ELParserTokenManager implements ELParserConstants
005    {
006      public  java.io.PrintStream debugStream = System.out;
007      public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
008    private 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    }
023    private final int jjStartNfa_0(int pos, long active0)
024    {
025       return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
026    }
027    private final int jjStopAtPos(int pos, int kind)
028    {
029       jjmatchedKind = kind;
030       jjmatchedPos = pos;
031       return pos + 1;
032    }
033    private 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    }
041    private 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    }
051    private 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    }
069    private final void jjCheckNAdd(int state)
070    {
071       if (jjrounds[state] != jjround)
072       {
073          jjstateSet[jjnewStateCnt++] = state;
074          jjrounds[state] = jjround;
075       }
076    }
077    private final void jjAddStates(int start, int end)
078    {
079       do {
080          jjstateSet[jjnewStateCnt++] = jjnextStates[start];
081       } while (start++ != end);
082    }
083    private final void jjCheckNAddTwoStates(int state1, int state2)
084    {
085       jjCheckNAdd(state1);
086       jjCheckNAdd(state2);
087    }
088    private final void jjCheckNAddStates(int start, int end)
089    {
090       do {
091          jjCheckNAdd(jjnextStates[start]);
092       } while (start++ != end);
093    }
094    private final void jjCheckNAddStates(int start)
095    {
096       jjCheckNAdd(jjnextStates[start]);
097       jjCheckNAdd(jjnextStates[start + 1]);
098    }
099    static final long[] jjbitVec0 = {
100       0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
101    };
102    static final long[] jjbitVec2 = {
103       0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
104    };
105    private 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    }
223    private 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    }
270    private final int jjStartNfa_1(int pos, long active0)
271    {
272       return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
273    }
274    private 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    }
282    private 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    }
353    private 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    }
419    private 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    }
455    private 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    }
483    private 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    }
507    static final long[] jjbitVec3 = {
508       0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
509    };
510    static final long[] jjbitVec4 = {
511       0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
512    };
513    static final long[] jjbitVec5 = {
514       0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
515    };
516    static final long[] jjbitVec6 = {
517       0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
518    };
519    static final long[] jjbitVec7 = {
520       0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
521    };
522    static final long[] jjbitVec8 = {
523       0x3fffffffffffL, 0x0L, 0x0L, 0x0L
524    };
525    private 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    }
839    static 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    };
843    private 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    }
855    private 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    }
875    public 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, 
882    null, };
883    public static final String[] lexStateNames = {
884       "DEFAULT", 
885       "IN_EXPRESSION", 
886    };
887    public 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    };
892    static final long[] jjtoToken = {
893       0x47fffffffffd87L, 
894    };
895    static final long[] jjtoSkip = {
896       0x78L, 
897    };
898    private SimpleCharStream input_stream;
899    private final int[] jjrounds = new int[35];
900    private final int[] jjstateSet = new int[70];
901    protected char curChar;
902    public 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    }
908    public ELParserTokenManager(SimpleCharStream stream, int lexState)
909    {
910       this(stream);
911       SwitchTo(lexState);
912    }
913    public void ReInit(SimpleCharStream stream)
914    {
915       jjmatchedPos = jjnewStateCnt = 0;
916       curLexState = defaultLexState;
917       input_stream = stream;
918       ReInitRounds();
919    }
920    private final void ReInitRounds()
921    {
922       int i;
923       jjround = 0x80000001;
924       for (i = 35; i-- > 0;)
925          jjrounds[i] = 0x80000000;
926    }
927    public void ReInit(SimpleCharStream stream, int lexState)
928    {
929       ReInit(stream);
930       SwitchTo(lexState);
931    }
932    public 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    
940    private 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    
953    int curLexState = 0;
954    int defaultLexState = 0;
955    int jjnewStateCnt;
956    int jjround;
957    int jjmatchedPos;
958    int jjmatchedKind;
959    
960    public 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    }