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