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