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