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