Source code: org/activemq/selector/SelectorParserTokenManager.java
1 /* Generated By:JavaCC: Do not edit this line. SelectorParserTokenManager.java */
2 package org.activemq.selector;
3 import java.io.*;
4 import java.util.*;
5 import javax.jms.InvalidSelectorException;
6 import org.activemq.filter.*;
7
8 public class SelectorParserTokenManager implements SelectorParserConstants
9 {
10 public java.io.PrintStream debugStream = System.out;
11 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
12 private final int jjStopAtPos(int pos, int kind)
13 {
14 jjmatchedKind = kind;
15 jjmatchedPos = pos;
16 return pos + 1;
17 }
18 private final int jjMoveStringLiteralDfa0_0()
19 {
20 switch(curChar)
21 {
22 case 9:
23 jjmatchedKind = 2;
24 return jjMoveNfa_0(5, 0);
25 case 10:
26 jjmatchedKind = 3;
27 return jjMoveNfa_0(5, 0);
28 case 12:
29 jjmatchedKind = 5;
30 return jjMoveNfa_0(5, 0);
31 case 13:
32 jjmatchedKind = 4;
33 return jjMoveNfa_0(5, 0);
34 case 32:
35 jjmatchedKind = 1;
36 return jjMoveNfa_0(5, 0);
37 case 37:
38 jjmatchedKind = 41;
39 return jjMoveNfa_0(5, 0);
40 case 40:
41 jjmatchedKind = 34;
42 return jjMoveNfa_0(5, 0);
43 case 41:
44 jjmatchedKind = 36;
45 return jjMoveNfa_0(5, 0);
46 case 42:
47 jjmatchedKind = 39;
48 return jjMoveNfa_0(5, 0);
49 case 43:
50 jjmatchedKind = 37;
51 return jjMoveNfa_0(5, 0);
52 case 44:
53 jjmatchedKind = 35;
54 return jjMoveNfa_0(5, 0);
55 case 45:
56 jjmatchedKind = 38;
57 return jjMoveNfa_0(5, 0);
58 case 47:
59 jjmatchedKind = 40;
60 return jjMoveNfa_0(5, 0);
61 case 60:
62 jjmatchedKind = 32;
63 return jjMoveStringLiteralDfa1_0(0x220000000L);
64 case 61:
65 jjmatchedKind = 28;
66 return jjMoveNfa_0(5, 0);
67 case 62:
68 jjmatchedKind = 30;
69 return jjMoveStringLiteralDfa1_0(0x80000000L);
70 case 65:
71 return jjMoveStringLiteralDfa1_0(0x200L);
72 case 66:
73 return jjMoveStringLiteralDfa1_0(0x800L);
74 case 69:
75 return jjMoveStringLiteralDfa1_0(0x2000L);
76 case 70:
77 return jjMoveStringLiteralDfa1_0(0x20000L);
78 case 73:
79 return jjMoveStringLiteralDfa1_0(0xc000L);
80 case 76:
81 return jjMoveStringLiteralDfa1_0(0x1000L);
82 case 78:
83 return jjMoveStringLiteralDfa1_0(0x40100L);
84 case 79:
85 return jjMoveStringLiteralDfa1_0(0x400L);
86 case 84:
87 return jjMoveStringLiteralDfa1_0(0x10000L);
88 case 88:
89 return jjMoveStringLiteralDfa1_0(0x180000L);
90 case 97:
91 return jjMoveStringLiteralDfa1_0(0x200L);
92 case 98:
93 return jjMoveStringLiteralDfa1_0(0x800L);
94 case 101:
95 return jjMoveStringLiteralDfa1_0(0x2000L);
96 case 102:
97 return jjMoveStringLiteralDfa1_0(0x20000L);
98 case 105:
99 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}