?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
First post!
[beagle.git] / Lucene.Net / Analysis / Standard / StandardTokenizerTokenManager.cs
blob6a4afd8949bd4d27ce7da6623201c38263513029
1 using System;
2 using System.IO;
3
4 namespace Lucene.Net.Analysis.Standard
5 {
6 public class StandardTokenizerTokenManager
7 {
8 public TextWriter debugStream = Console.Out;
9 public void setDebugStream(TextWriter ds) { debugStream = ds; }
10 private int jjMoveStringLiteralDfa0_0()
11 {
12 return jjMoveNfa_0(0, 0);
13 }
14 private void jjCheckNAdd(int state)
15 {
16 if (jjrounds[state] != jjround)
17 {
18 jjstateSet[jjnewStateCnt++] = (uint)state;
19 jjrounds[state] = (uint)jjround;
20 }
21 }
22 private void jjAddStates(int start, int end)
23 {
24 do
25 {
26 jjstateSet[jjnewStateCnt++] = (uint)jjnextStates[start];
27 } while (start++ != end);
28 }
29 private void jjCheckNAddTwoStates(int state1, int state2)
30 {
31 jjCheckNAdd(state1);
32 jjCheckNAdd(state2);
33 }
34 private void jjCheckNAddStates(int start, int end)
35 {
36 do
37 {
38 jjCheckNAdd(jjnextStates[start]);
39 } while (start++ != end);
40 }
41 private void jjCheckNAddStates(int start)
42 {
43 jjCheckNAdd(jjnextStates[start]);
44 jjCheckNAdd(jjnextStates[start + 1]);
45 }
46 readonly ulong[] jjbitVec0 = {
47 0x1600UL, 0x0UL, 0x0UL, 0x0UL
48
49 };
50 readonly ulong[] jjbitVec1 = {
51 0x0UL, 0xffc000000000UL, 0x0UL, 0xffc000000000UL
52 };
53 readonly ulong[] jjbitVec2 = {
54 0x0UL, 0x3ff00000000UL, 0x0UL, 0x3ff000000000000UL
55 };
56 readonly ulong[] jjbitVec3 = {
57 0x0UL, 0xffc000000000UL, 0x0UL, 0xff8000000000UL
58 };
59 readonly ulong[] jjbitVec4 = {
60 0x0UL, 0xffc000000000UL, 0x0UL, 0x0UL
61 };
62 readonly ulong[] jjbitVec5 = {
63 0x0UL, 0x3ff0000UL, 0x0UL, 0x3ff0000UL
64 };
65 readonly ulong[] jjbitVec6 = {
66 0x0UL, 0x3ffUL, 0x0UL, 0x0UL
67 };
68 readonly ulong[] jjbitVec7 = {
69 0x1ff00000fffffffeUL, 0xffffffffffffc000UL, 0xffffffffUL, 0x600000000000000UL
70 };
71 readonly ulong[] jjbitVec9 = {
72 0x0UL, 0x0UL, 0x0UL, 0xff7fffffff7fffffUL
73 };
74 readonly ulong[] jjbitVec10 = {
75 0x0UL, 0xffffffffffffffffUL, 0xffffffffffffffffUL, 0xffffffffffffffffUL
76 };
77 readonly ulong[] jjbitVec11 = {
78 0xffffffffffffffffUL, 0xffffffffffffffffUL, 0xffffUL, 0x0UL
79 };
80 readonly ulong[] jjbitVec12 = {
81 0xffffffffffffffffUL, 0xffffffffffffffffUL, 0x0UL, 0x0UL
82 };
83 readonly ulong[] jjbitVec13 = {
84 0x3fffffffffffUL, 0x0UL, 0x0UL, 0x0UL
85 };
86 private int jjMoveNfa_0(int startState, int curPos)
87 {
88 //int[] nextStates;
89 int startsAt = 0;
90 jjnewStateCnt = 74;
91 int i = 1;
92 jjstateSet[0] = (uint)startState;
93 int kind = 0x7fffffff;
94 for (;;)
95 {
96 if (++jjround == 0x7fffffff)
97 ReInitRounds();
98 if (curChar < 64)
99 {
100 long l = 1L << curChar;
101 do
102 {
103 switch(jjstateSet[--i])
104 {
105 case 0:
106 if ((0x3ff000000000000L & l) != 0L)
107 {
108 if (kind > 1)
109 kind = 1;
110 jjCheckNAddStates(0, 17);
111 }
112 if ((0x3ff000000000000L & l) != 0L)
113 jjCheckNAddStates(18, 23);
114 break;
115 case 1:
116 case 40:
117 if ((0x3ff000000000000L & l) != 0L)
118 jjCheckNAddTwoStates(1, 2);
119 break;
120 case 2:
121 if ((0xf00000000000L & l) != 0L)
122 jjCheckNAdd(3);
123 break;
124 case 3:
125 if ((0x3ff000000000000L & l) == 0L)
126 break;
127 if (kind > 7)
128 kind = 7;
129 jjCheckNAdd(3);
130 break;
131 case 4:
132 case 49:
133 if ((0x3ff000000000000L & l) != 0L)
134 jjCheckNAddTwoStates(4, 5);
135 break;
136 case 5:
137 if ((0xf00000000000L & l) != 0L)
138 jjCheckNAdd(6);
139 break;
140 case 6:
141 if ((0x3ff000000000000L & l) != 0L)
142 jjCheckNAddTwoStates(6, 7);
143 break;
144 case 7:
145 if ((0xf00000000000L & l) != 0L)
146 jjCheckNAddTwoStates(8, 9);
147 break;
148 case 8:
149 if ((0x3ff000000000000L & l) != 0L)
150 jjCheckNAddTwoStates(8, 9);
151 break;
152 case 9:
153 case 10:
154 if ((0x3ff000000000000L & l) == 0L)
155 break;
156 if (kind > 7)
157 kind = 7;
158 jjCheckNAddTwoStates(5, 10);
159 break;
160 case 11:
161 case 62:
162 if ((0x3ff000000000000L & l) != 0L)
163 jjCheckNAddTwoStates(11, 12);
164 break;
165 case 12:
166 if ((0xf00000000000L & l) != 0L)
167 jjCheckNAdd(13);
168 break;
169 case 13:
170 if ((0x3ff000000000000L & l) != 0L)
171 jjCheckNAddTwoStates(13, 14);
172 break;
173 case 14:
174 if ((0xf00000000000L & l) != 0L)
175 jjCheckNAddTwoStates(15, 16);
176 break;
177 case 15:
178 if ((0x3ff000000000000L & l) != 0L)
179 jjCheckNAddTwoStates(15, 16);
180 break;
181 case 16:
182 case 17:
183 if ((0x3ff000000000000L & l) != 0L)
184 jjCheckNAddTwoStates(17, 18);
185 break;
186 case 18:
187 if ((0xf00000000000L & l) != 0L)
188 jjCheckNAdd(19);
189 break;
190 case 19:
191 if ((0x3ff000000000000L & l) == 0L)
192 break;
193 if (kind > 7)
194 kind = 7;
195 jjCheckNAddTwoStates(14, 19);
196 break;
197 case 20:
198 if ((0x3ff000000000000L & l) == 0L)
199 break;
200 if (kind > 1)
201 kind = 1;
202 jjCheckNAddStates(0, 17);
203 break;
204 case 21:
205 if ((0x3ff000000000000L & l) == 0L)
206 break;
207 if (kind > 1)
208 kind = 1;
209 jjCheckNAdd(21);
210 break;
211 case 22:
212 if ((0x3ff000000000000L & l) != 0L)
213 jjCheckNAddStates(24, 26);
214 break;
215 case 23:
216 if ((0x600000000000L & l) != 0L)
217 jjCheckNAddStates(27, 29);
218 break;
219 case 25:
220 if ((0x3ff000000000000L & l) != 0L)
221 jjCheckNAddStates(30, 33);
222 break;
223 case 27:
224 if ((0x3ff000000000000L & l) != 0L)
225 jjCheckNAddStates(34, 36);
226 break;
227 case 28:
228 if (curChar != 46)
229 break;
230 if (kind > 5)
231 kind = 5;
232 jjCheckNAddTwoStates(28, 29);
233 break;
234 case 29:
235 if (curChar == 45)
236 jjCheckNAdd(30);
237 break;
238 case 30:
239 if ((0x3ff000000000000L & l) == 0L)
240 break;
241 if (kind > 5)
242 kind = 5;
243 jjCheckNAddStates(37, 39);
244 break;
245 case 31:
246 if ((0x3ff000000000000L & l) != 0L)
247 jjCheckNAddTwoStates(31, 32);
248 break;
249 case 32:
250 if (curChar == 46)
251 jjCheckNAdd(33);
252 break;
253 case 33:
254 if ((0x3ff000000000000L & l) == 0L)
255 break;
256 if (kind > 6)
257 kind = 6;
258 jjCheckNAddTwoStates(32, 33);
259 break;
260 case 34:
261 if ((0x3ff000000000000L & l) != 0L)
262 jjCheckNAddTwoStates(34, 35);
263 break;
264 case 35:
265 if ((0xf00000000000L & l) != 0L)
266 jjCheckNAddTwoStates(36, 37);
267 break;
268 case 36:
269 if ((0x3ff000000000000L & l) != 0L)
270 jjCheckNAddTwoStates(36, 37);
271 break;
272 case 37:
273 case 38:
274 if ((0x3ff000000000000L & l) == 0L)
275 break;
276 if (kind > 7)
277 kind = 7;
278 jjCheckNAdd(38);
279 break;
280 case 39:
281 if ((0x3ff000000000000L & l) != 0L)
282 jjCheckNAddTwoStates(39, 40);
283 break;
284 case 41:
285 if ((0x3ff000000000000L & l) != 0L)
286 jjCheckNAddTwoStates(41, 42);
287 break;
288 case 42:
289 if ((0xf00000000000L & l) != 0L)
290 jjCheckNAddTwoStates(43, 44);
291 break;
292 case 43:
293 if ((0x3ff000000000000L & l) != 0L)
294 jjCheckNAddTwoStates(43, 44);
295 break;
296 case 44:
297 case 45:
298 if ((0x3ff000000000000L & l) != 0L)
299 jjCheckNAddTwoStates(45, 46);
300 break;
301 case 46:
302 if ((0xf00000000000L & l) != 0L)
303 jjCheckNAdd(47);
304 break;
305 case 47:
306 if ((0x3ff000000000000L & l) == 0L)
307 break;
308 if (kind > 7)
309 kind = 7;
310 jjCheckNAddTwoStates(42, 47);
311 break;
312 case 48:
313 if ((0x3ff000000000000L & l) != 0L)
314 jjCheckNAddTwoStates(48, 49);
315 break;
316 case 50:
317 if ((0x3ff000000000000L & l) != 0L)
318 jjCheckNAddTwoStates(50, 51);
319 break;
320 case 51:
321 if ((0xf00000000000L & l) != 0L)
322 jjCheckNAddTwoStates(52, 53);
323 break;
324 case 52:
325 if ((0x3ff000000000000L & l) != 0L)
326 jjCheckNAddTwoStates(52, 53);
327 break;
328 case 53:
329 case 54:
330 if ((0x3ff000000000000L & l) != 0L)
331 jjCheckNAddTwoStates(54, 55);
332 break;
333 case 55:
334 if ((0xf00000000000L & l) != 0L)
335 jjCheckNAdd(56);
336 break;
337 case 56:
338 if ((0x3ff000000000000L & l) != 0L)
339 jjCheckNAddTwoStates(56, 57);
340 break;
341 case 57:
342 if ((0xf00000000000L & l) != 0L)
343 jjCheckNAddTwoStates(58, 59);
344 break;
345 case 58:
346 if ((0x3ff000000000000L & l) != 0L)
347 jjCheckNAddTwoStates(58, 59);
348 break;
349 case 59:
350 case 60:
351 if ((0x3ff000000000000L & l) == 0L)
352 break;
353 if (kind > 7)
354 kind = 7;
355 jjCheckNAddTwoStates(55, 60);
356 break;
357 case 61:
358 if ((0x3ff000000000000L & l) != 0L)
359 jjCheckNAddTwoStates(61, 62);
360 break;
361 case 65:
362 if (curChar == 39)
363 jjstateSet[jjnewStateCnt++] = 66;
364 break;
365 case 68:
366 if (curChar == 46)
367 jjCheckNAdd(69);
368 break;
369 case 70:
370 if (curChar != 46)
371 break;
372 if (kind > 3)
373 kind = 3;
374 jjCheckNAdd(69);
375 break;
376 case 72:
377 if (curChar == 38)
378 jjstateSet[jjnewStateCnt++] = 73;
379 break;
380 default : break;
381 }
382 } while(i != startsAt);
383 }
384 else if (curChar < 128)
385 {
386 long l = 1L << (curChar & 63);
387 do
388 {
389 switch(jjstateSet[--i])
390 {
391 case 0:
392 if ((0x7fffffe07fffffeL & l) != 0L)
393 jjCheckNAddStates(40, 45);
394 if ((0x7fffffe07fffffeL & l) != 0L)
395 {
396 if (kind > 1)
397 kind = 1;
398 jjCheckNAddStates(0, 17);
399 }
400 break;
401 case 1:
402 if ((0x7fffffe07fffffeL & l) != 0L)
403 jjAddStates(46, 47);
404 break;
405 case 2:
406 if (curChar == 95)
407 jjCheckNAdd(3);
408 break;
409 case 3:
410 if ((0x7fffffe07fffffeL & l) == 0L)
411 break;
412 if (kind > 7)
413 kind = 7;
414 jjCheckNAdd(3);
415 break;
416 case 4:
417 if ((0x7fffffe07fffffeL & l) != 0L)
418 jjCheckNAddTwoStates(4, 5);
419 break;
420 case 5:
421 if (curChar == 95)
422 jjCheckNAdd(6);
423 break;
424 case 6:
425 if ((0x7fffffe07fffffeL & l) != 0L)
426 jjCheckNAddTwoStates(6, 7);
427 break;
428 case 7:
429 if (curChar == 95)
430 jjCheckNAddTwoStates(8, 9);
431 break;
432 case 8:
433 if ((0x7fffffe07fffffeL & l) != 0L)
434 jjCheckNAddTwoStates(8, 9);
435 break;
436 case 10:
437 if ((0x7fffffe07fffffeL & l) == 0L)
438 break;
439 if (kind > 7)
440 kind = 7;
441 jjCheckNAddTwoStates(5, 10);
442 break;
443 case 11:
444 if ((0x7fffffe07fffffeL & l) != 0L)
445 jjAddStates(48, 49);
446 break;
447 case 12:
448 if (curChar == 95)
449 jjCheckNAdd(13);
450 break;
451 case 13:
452 if ((0x7fffffe07fffffeL & l) != 0L)
453 jjCheckNAddTwoStates(13, 14);
454 break;
455 case 14:
456 if (curChar == 95)
457 jjCheckNAddTwoStates(15, 16);
458 break;
459 case 15:
460 if ((0x7fffffe07fffffeL & l) != 0L)
461 jjCheckNAddTwoStates(15, 16);
462 break;
463 case 17:
464 if ((0x7fffffe07fffffeL & l) != 0L)
465 jjAddStates(50, 51);
466 break;
467 case 18:
468 if (curChar == 95)
469 jjCheckNAdd(19);
470 break;
471 case 19:
472 if ((0x7fffffe07fffffeL & l) == 0L)
473 break;
474 if (kind > 7)
475 kind = 7;
476 jjCheckNAddTwoStates(14, 19);
477 break;
478 case 20:
479 if ((0x7fffffe07fffffeL & l) == 0L)
480 break;
481 if (kind > 1)
482 kind = 1;
483 jjCheckNAddStates(0, 17);
484 break;
485 case 21:
486 if ((0x7fffffe07fffffeL & l) == 0L)
487 break;
488 if (kind > 1)
489 kind = 1;
490 jjCheckNAdd(21);
491 break;
492 case 22:
493 if ((0x7fffffe07fffffeL & l) != 0L)
494 jjCheckNAddStates(24, 26);
495 break;
496 case 24:
497 if (curChar == 95)
498 jjCheckNAdd(25);
499 break;
500 case 25:
501 if ((0x7fffffe07fffffeL & l) != 0L)
502 jjCheckNAddStates(30, 33);
503 break;
504 case 26:
505 if (curChar == 64)
506 jjCheckNAdd(27);
507 break;
508 case 27:
509 if ((0x7fffffe07fffffeL & l) != 0L)
510 jjCheckNAddStates(34, 36);
511 break;
512 case 30:
513 if ((0x7fffffe07fffffeL & l) == 0L)
514 break;
515 if (kind > 5)
516 kind = 5;
517 jjCheckNAddStates(37, 39);
518 break;
519 case 31:
520 if ((0x7fffffe07fffffeL & l) != 0L)
521 jjCheckNAddTwoStates(31, 32);
522 break;
523 case 33:
524 if ((0x7fffffe07fffffeL & l) == 0L)
525 break;
526 if (kind > 6)
527 kind = 6;
528 jjCheckNAddTwoStates(32, 33);
529 break;
530 case 34:
531 if ((0x7fffffe07fffffeL & l) != 0L)
532 jjCheckNAddTwoStates(34, 35);
533 break;
534 case 35:
535 if (curChar == 95)
536 jjCheckNAddTwoStates(36, 37);
537 break;
538 case 36:
539 if ((0x7fffffe07fffffeL & l) != 0L)
540 jjCheckNAddTwoStates(36, 37);
541 break;
542 case 38:
543 if ((0x7fffffe07fffffeL & l) == 0L)
544 break;
545 if (kind > 7)
546 kind = 7;
547 jjstateSet[jjnewStateCnt++] = 38;
548 break;
549 case 39:
550 if ((0x7fffffe07fffffeL & l) != 0L)
551 jjCheckNAddTwoStates(39, 40);
552 break;
553 case 41:
554 if ((0x7fffffe07fffffeL & l) != 0L)
555 jjCheckNAddTwoStates(41, 42);
556 break;
557 case 42:
558 if (curChar == 95)
559 jjCheckNAddTwoStates(43, 44);
560 break;
561 case 43:
562 if ((0x7fffffe07fffffeL & l) != 0L)
563 jjCheckNAddTwoStates(43, 44);
564 break;
565 case 45:
566 if ((0x7fffffe07fffffeL & l) != 0L)
567 jjAddStates(52, 53);
568 break;
569 case 46:
570 if (curChar == 95)
571 jjCheckNAdd(47);
572 break;
573 case 47:
574 if ((0x7fffffe07fffffeL & l) == 0L)
575 break;
576 if (kind > 7)
577 kind = 7;
578 jjCheckNAddTwoStates(42, 47);
579 break;
580 case 48:
581 if ((0x7fffffe07fffffeL & l) != 0L)
582 jjCheckNAddTwoStates(48, 49);
583 break;
584 case 50:
585 if ((0x7fffffe07fffffeL & l) != 0L)
586 jjCheckNAddTwoStates(50, 51);
587 break;
588 case 51:
589 if (curChar == 95)
590 jjCheckNAddTwoStates(52, 53);
591 break;
592 case 52:
593 if ((0x7fffffe07fffffeL & l) != 0L)
594 jjCheckNAddTwoStates(52, 53);
595 break;
596 case 54:
597 if ((0x7fffffe07fffffeL & l) != 0L)
598 jjCheckNAddTwoStates(54, 55);
599 break;
600 case 55:
601 if (curChar == 95)
602 jjCheckNAdd(56);
603 break;
604 case 56:
605 if ((0x7fffffe07fffffeL & l) != 0L)
606 jjCheckNAddTwoStates(56, 57);
607 break;
608 case 57:
609 if (curChar == 95)
610 jjCheckNAddTwoStates(58, 59);
611 break;
612 case 58:
613 if ((0x7fffffe07fffffeL & l) != 0L)
614 jjCheckNAddTwoStates(58, 59);
615 break;
616 case 60:
617 if ((0x7fffffe07fffffeL & l) == 0L)
618 break;
619 if (kind > 7)
620 kind = 7;
621 jjCheckNAddTwoStates(55, 60);
622 break;
623 case 61:
624 if ((0x7fffffe07fffffeL & l) != 0L)
625 jjCheckNAddTwoStates(61, 62);
626 break;
627 case 63:
628 if ((0x7fffffe07fffffeL & l) != 0L)
629 jjCheckNAddStates(40, 45);
630 break;
631 case 64:
632 if ((0x7fffffe07fffffeL & l) != 0L)
633 jjCheckNAddTwoStates(64, 65);
634 break;
635 case 66:
636 if ((0x7fffffe07fffffeL & l) == 0L)
637 break;
638 if (kind > 2)
639 kind = 2;
640 jjCheckNAddTwoStates(65, 66);
641 break;
642 case 67:
643 if ((0x7fffffe07fffffeL & l) != 0L)
644 jjCheckNAddTwoStates(67, 68);
645 break;
646 case 69:
647 if ((0x7fffffe07fffffeL & l) != 0L)
648 jjAddStates(54, 55);
649 break;
650 case 71:
651 if ((0x7fffffe07fffffeL & l) != 0L)
652 jjCheckNAddTwoStates(71, 72);
653 break;
654 case 72:
655 if (curChar == 64)
656 jjCheckNAdd(73);
657 break;
658 case 73:
659 if ((0x7fffffe07fffffeL & l) == 0L)
660 break;
661 if (kind > 4)
662 kind = 4;
663 jjCheckNAdd(73);
664 break;
665 default : break;
666 }
667 } while(i != startsAt);
668 }
669 else
670 {
671 int i2 = (curChar & 0xff) >> 6;
672 ulong l2 = 1ul << (curChar & 63);
673 do
674 {
675 switch(jjstateSet[--i])
676 {
677 case 0:
678 if ((jjbitVec2[i2] & l2) != 0ul)
679 jjCheckNAddStates(18, 23);
680 if ((jjbitVec9[i2] & l2) != 0ul)
681 {
682 if (kind > 1)
683 kind = 1;
684 jjCheckNAddStates(0, 17);
685 }
686 if ((jjbitVec9[i2] & l2) != 0UL)
687 jjCheckNAddStates(40, 45);
688 break;
689 case 1:
690 if ((jjbitVec9[i2] & l2) != 0UL)
691 jjCheckNAddTwoStates(1, 2);
692 break;
693 case 3:
694 if ((jjbitVec9[i2] & l2) == 0UL)
695 break;
696 if (kind > 7)
697 kind = 7;
698 jjstateSet[jjnewStateCnt++] = 3;
699 break;
700 case 4:
701 if ((jjbitVec9[i2] & l2) != 0UL)
702 jjCheckNAddTwoStates(4, 5);
703 break;
704 case 6:
705 if ((jjbitVec9[i2] & l2) != 0UL)
706 jjAddStates(56, 57);
707 break;
708 case 8:
709 if ((jjbitVec9[i2] & l2) != 0UL)
710 jjAddStates(58, 59);
711 break;
712 case 9:
713 if ((jjbitVec2[i2] & l2) == 0UL)
714 break;
715 if (kind > 7)
716 kind = 7;
717 jjCheckNAddTwoStates(5, 10);
718 break;
719 case 10:
720 if ((jjbitVec9[i2] & l2) == 0UL)
721 break;
722 if (kind > 7)
723 kind = 7;
724 jjCheckNAddTwoStates(5, 10);
725 break;
726 case 11:
727 if ((jjbitVec9[i2] & l2) != 0UL)
728 jjCheckNAddTwoStates(11, 12);
729 break;
730 case 13:
731 if ((jjbitVec9[i2] & l2) != 0UL)
732 jjCheckNAddTwoStates(13, 14);
733 break;
734 case 15:
735 if ((jjbitVec9[i2] & l2) != 0UL)
736 jjAddStates(60, 61);
737 break;
738 case 16:
739 if ((jjbitVec2[i2] & l2) != 0UL)
740 jjCheckNAddTwoStates(17, 18);
741 break;
742 case 17:
743 if ((jjbitVec9[i2] & l2) != 0UL)
744 jjCheckNAddTwoStates(17, 18);
745 break;
746 case 19:
747 if ((jjbitVec9[i2] & l2) == 0UL)
748 break;
749 if (kind > 7)
750 kind = 7;
751 jjCheckNAddTwoStates(14, 19);
752 break;
753 case 20:
754 if ((jjbitVec9[i2] & l2) == 0UL)
755 break;
756 if (kind > 1)
757 kind = 1;
758 jjCheckNAddStates(0, 17);
759 break;
760 case 21:
761 if ((jjbitVec9[i2] & l2) == 0UL)
762 break;
763 if (kind > 1)
764 kind = 1;
765 jjCheckNAdd(21);
766 break;
767 case 22:
768 if ((jjbitVec9[i2] & l2) != 0UL)
769 jjCheckNAddStates(24, 26);
770 break;
771 case 25:
772 if ((jjbitVec9[i2] & l2) != 0UL)
773 jjCheckNAddStates(30, 33);
774 break;
775 case 27:
776 if ((jjbitVec9[i2] & l2) != 0UL)
777 jjCheckNAddStates(34, 36);
778 break;
779 case 30:
780 if ((jjbitVec9[i2] & l2) == 0UL)
781 break;
782 if (kind > 5)
783 kind = 5;
784 jjCheckNAddStates(37, 39);
785 break;
786 case 31:
787 if ((jjbitVec9[i2] & l2) != 0UL)
788 jjCheckNAddTwoStates(31, 32);
789 break;
790 case 33:
791 if ((jjbitVec9[i2] & l2) == 0UL)
792 break;
793 if (kind > 6)
794 kind = 6;
795 jjCheckNAddTwoStates(32, 33);
796 break;
797 case 34:
798 if ((jjbitVec9[i2] & l2) != 0UL)
799 jjCheckNAddTwoStates(34, 35);
800 break;
801 case 36:
802 if ((jjbitVec9[i2] & l2) != 0UL)
803 jjAddStates(62, 63);
804 break;
805 case 37:
806 if ((jjbitVec2[i2] & l2) == 0UL)
807 break;
808 if (kind > 7)
809 kind = 7;
810 jjCheckNAdd(38);
811 break;
812 case 38:
813 if ((jjbitVec9[i2] & l2) == 0UL)
814 break;
815 if (kind > 7)
816 kind = 7;
817 jjCheckNAdd(38);
818 break;
819 case 39:
820 if ((jjbitVec9[i2] & l2) != 0UL)
821 jjCheckNAddTwoStates(39, 40);
822 break;
823 case 40:
824 if ((jjbitVec2[i2] & l2) != 0UL)
825 jjCheckNAddTwoStates(1, 2);
826 break;
827 case 41:
828 if ((jjbitVec9[i2] & l2) != 0UL)
829 jjCheckNAddTwoStates(41, 42);
830 break;
831 case 43:
832 if ((jjbitVec9[i2] & l2) != 0UL)
833 jjAddStates(64, 65);
834 break;
835 case 44:
836 if ((jjbitVec2[i2] & l2) != 0UL)
837 jjCheckNAddTwoStates(45, 46);
838 break;
839 case 45:
840 if ((jjbitVec9[i2] & l2) != 0UL)
841 jjCheckNAddTwoStates(45, 46);
842 break;
843 case 47:
844 if ((jjbitVec9[i2] & l2) == 0UL)
845 break;
846 if (kind > 7)
847 kind = 7;
848 jjCheckNAddTwoStates(42, 47);
849 break;
850 case 48:
851 if ((jjbitVec9[i2] & l2) != 0UL)
852 jjCheckNAddTwoStates(48, 49);
853 break;
854 case 49:
855 if ((jjbitVec2[i2] & l2) != 0UL)
856 jjCheckNAddTwoStates(4, 5);
857 break;
858 case 50:
859 if ((jjbitVec9[i2] & l2) != 0UL)
860 jjCheckNAddTwoStates(50, 51);
861 break;
862 case 52:
863 if ((jjbitVec9[i2] & l2) != 0UL)
864 jjAddStates(66, 67);
865 break;
866 case 53:
867 if ((jjbitVec2[i2] & l2) != 0UL)
868 jjCheckNAddTwoStates(54, 55);
869 break;
870 case 54:
871 if ((jjbitVec9[i2] & l2) != 0UL)
872 jjCheckNAddTwoStates(54, 55);
873 break;
874 case 56:
875 if ((jjbitVec9[i2] & l2) != 0UL)
876 jjAddStates(68, 69);
877 break;
878 case 58:
879 if ((jjbitVec9[i2] & l2) != 0UL)
880 jjAddStates(70, 71);
881 break;
882 case 59:
883 if ((jjbitVec2[i2] & l2) == 0UL)
884 break;
885 if (kind > 7)
886 kind = 7;
887 jjCheckNAddTwoStates(55, 60);
888 break;
889 case 60:
890 if ((jjbitVec9[i2] & l2) == 0UL)
891 break;
892 if (kind > 7)
893 kind = 7;
894 jjCheckNAddTwoStates(55, 60);
895 break;
896 case 61:
897 if ((jjbitVec9[i2] & l2) != 0UL)
898 jjCheckNAddTwoStates(61, 62);
899 break;
900 case 62:
901 if ((jjbitVec2[i2] & l2) != 0UL)
902 jjCheckNAddTwoStates(11, 12);
903 break;
904 case 63:
905 if ((jjbitVec9[i2] & l2) != 0UL)
906 jjCheckNAddStates(40, 45);
907 break;
908 case 64:
909 if ((jjbitVec9[i2] & l2) != 0UL)
910 jjCheckNAddTwoStates(64, 65);
911 break;
912 case 66:
913 if ((jjbitVec9[i2] & l2) == 0UL)
914 break;
915 if (kind > 2)
916 kind = 2;
917 jjCheckNAddTwoStates(65, 66);
918 break;
919 case 67:
920 if ((jjbitVec9[i2] & l2) != 0UL)
921 jjCheckNAddTwoStates(67, 68);
922 break;
923 case 69:
924 if ((jjbitVec9[i2] & l2) != 0UL)
925 jjAddStates(54, 55);
926 break;
927 case 71:
928 if ((jjbitVec9[i2] & l2) != 0UL)
929 jjCheckNAddTwoStates(71, 72);
930 break;
931 case 73:
932 if ((jjbitVec9[i2] & l2) == 0UL)
933 break;
934 if (kind > 4)
935 kind = 4;
936 jjstateSet[jjnewStateCnt++] = 73;
937 break;
938 default : break;
939 }
940 } while(i != startsAt);
941 }
942 if (kind != 0x7fffffff)
943 {
944 jjmatchedKind = kind;
945 jjmatchedPos = curPos;
946 kind = 0x7fffffff;
947 }
948 ++curPos;
949 if ((i = jjnewStateCnt) == (startsAt = 74 - (jjnewStateCnt = startsAt)))
950 return curPos;
951 try { curChar = input_stream.ReadChar(); }
952 catch(IOException) { return curPos; }
953 }
954 }
955 readonly int[] jjnextStates = {
956 21, 22, 23, 24, 31, 32, 34, 35, 39, 40, 41, 42, 48, 49, 50, 51,
957 61, 62, 1, 2, 4, 5, 11, 12, 22, 23, 24, 23, 24, 26, 23, 24,
958 25, 26, 27, 28, 29, 28, 29, 30, 64, 65, 67, 68, 71, 72, 1, 2,
959 11, 12, 17, 18, 45, 46, 69, 70, 6, 7, 8, 9, 15, 16, 36, 37,
960 43, 44, 52, 53, 56, 57, 58, 59,
961 };
962 public readonly String[] jjstrLiteralImages = new String[]
963 {
964 "", null, null, null, null, null, null, null, null, null, null, null, null,
965 null, };
966 public readonly String[] lexStateNames = new String[]
967 {
968 "DEFAULT",
969 };
970 readonly long[] jjtoToken = new long[] {
971 0xffL,
972 };
973 readonly long[] jjtoSkip = new long[] {
974 0x2000L,
975 };
976 protected CharStream input_stream;
977 private readonly uint[] jjrounds = new uint[74];
978 private readonly uint[] jjstateSet = new uint[148];
979 protected char curChar;
980 public StandardTokenizerTokenManager(CharStream stream)
981 {
982 input_stream = stream;
983 }
984 public StandardTokenizerTokenManager(CharStream stream, int lexState) : this(stream)
985 {
986 SwitchTo(lexState);
987 }
988 public void ReInit(CharStream stream)
989 {
990 jjmatchedPos = jjnewStateCnt = 0;
991 curLexState = defaultLexState;
992 input_stream = stream;
993 ReInitRounds();
994 }
995 private void ReInitRounds()
996 {
997 int i;
998 jjround = 0x80000001;
999 for (i = 74; i-- > 0;)
1000 jjrounds[i] = 0x80000000;
1001 }
1002 public void ReInit(CharStream stream, int lexState)
1003 {
1004 ReInit(stream);
1005 SwitchTo(lexState);
1006 }
1007 public void SwitchTo(int lexState)
1008 {
1009 if (lexState >= 1 || lexState < 0)
1010 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1011 else
1012 curLexState = lexState;
1013 }
1014
1015 protected Token jjFillToken()
1016 {
1017 Token t = Token.NewToken(jjmatchedKind);
1018 t.kind = jjmatchedKind;
1019 String im = jjstrLiteralImages[jjmatchedKind];
1020 t.image = (im == null) ? input_stream.GetImage() : im;
1021 t.beginLine = input_stream.GetBeginLine();
1022 t.beginColumn = input_stream.GetBeginColumn();
1023 t.endLine = input_stream.GetEndLine();
1024 t.endColumn = input_stream.GetEndColumn();
1025 return t;
1026 }
1027
1028 int curLexState = 0;
1029 int defaultLexState = 0;
1030 int jjnewStateCnt;
1031 uint jjround;
1032 int jjmatchedPos;
1033 int jjmatchedKind;
1034
1035 public Token GetNextToken()
1036 {
1037 Token matchedToken;
1038 int curPos = 0;
1039
1040 EOFLoop :
1041 for (;;)
1042 {
1043 try
1044 {
1045 curChar = input_stream.BeginToken();
1046 }
1047 catch(IOException)
1048 {
1049 jjmatchedKind = 0;
1050 matchedToken = jjFillToken();
1051 return matchedToken;
1052 }
1053
1054 jjmatchedKind = 0x7fffffff;
1055 jjmatchedPos = 0;
1056 curPos = jjMoveStringLiteralDfa0_0();
1057 if (jjmatchedPos == 0 && jjmatchedKind > 13)
1058 {
1059 jjmatchedKind = 13;
1060 }
1061 if (jjmatchedKind != 0x7fffffff)
1062 {
1063 if (jjmatchedPos + 1 < curPos)
1064 input_stream.Backup(curPos - jjmatchedPos - 1);
1065 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)
1066 {
1067 matchedToken = jjFillToken();
1068 return matchedToken;
1069 }
1070 else
1071 {
1072 goto EOFLoop;
1073 }
1074 }
1075 int error_line = input_stream.GetEndLine();
1076 int error_column = input_stream.GetEndColumn();
1077 String error_after = null;
1078 bool EOFSeen = false;
1079 try { input_stream.ReadChar(); input_stream.Backup(1); }
1080 catch (IOException)
1081 {
1082 EOFSeen = true;
1083 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1084 if (curChar == '\n' || curChar == '\r')
1085 {
1086 error_line++;
1087 error_column = 0;
1088 }
1089 else
1090 error_column++;
1091 }
1092 if (!EOFSeen)
1093 {
1094 input_stream.Backup(1);
1095 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1096 }
1097 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1098 }
1099 }
1100
1101 }
1102 }
A Beagle Git Repo