1
2 package JADE_SL.lang.sl;
3 import JADE_SL.abs.*;
4 import JADE_SL.onto.Ontology;
5 import JADE_SL.CaseInsensitiveString;
6 import JADE_SL.lang.Codec;
7 import JADE_SL.*;
8 import java.io.ByteArrayInputStream;
9 import java.io.StringReader;
10 import java.util.Date;
11
12 public class SLParserTokenManager implements SLParserConstants
13 {
14 private final int jjStopStringLiteralDfa_1(int pos, long active0)
15 {
16 switch (pos)
17 {
18 case 0:
19 if ((active0 & 0x400000L) != 0L)
20 {
21 jjmatchedKind = 31;
22 return 42;
23 }
24 if ((active0 & 0x10000000L) != 0L)
25 {
26 jjmatchedKind = 31;
27 return 12;
28 }
29 return -1;
30 case 1:
31 if ((active0 & 0x10400000L) != 0L)
32 {
33 jjmatchedKind = 31;
34 jjmatchedPos = 1;
35 return 12;
36 }
37 return -1;
38 case 2:
39 if ((active0 & 0x10000000L) != 0L)
40 return 12;
41 if ((active0 & 0x400000L) != 0L)
42 {
43 jjmatchedKind = 31;
44 jjmatchedPos = 2;
45 return 12;
46 }
47 return -1;
48 case 3:
49 if ((active0 & 0x400000L) != 0L)
50 {
51 jjmatchedKind = 31;
52 jjmatchedPos = 3;
53 return 12;
54 }
55 return -1;
56 case 4:
57 if ((active0 & 0x400000L) != 0L)
58 {
59 jjmatchedKind = 31;
60 jjmatchedPos = 4;
61 return 12;
62 }
63 return -1;
64 default :
65 return -1;
66 }
67 }
68 private final int jjStartNfa_1(int pos, long active0)
69 {
70 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
71 }
72 private final int jjStopAtPos(int pos, int kind)
73 {
74 jjmatchedKind = kind;
75 jjmatchedPos = pos;
76 return pos + 1;
77 }
78 private final int jjStartNfaWithStates_1(int pos, int kind, int state)
79 {
80 jjmatchedKind = kind;
81 jjmatchedPos = pos;
82 try { curChar = input_stream.readChar(); }
83 catch(java.io.IOException e) { return pos + 1; }
84 return jjMoveNfa_1(state, pos + 1);
85 }
86 private final int jjMoveStringLiteralDfa0_1()
87 {
88 switch(curChar)
89 {
90 case 40:
91 return jjStopAtPos(0, 20);
92 case 41:
93 return jjStopAtPos(0, 21);
94 case 65:
95 case 97:
96 return jjMoveStringLiteralDfa1_1(0x400000L);
97 case 78:
98 case 110:
99 return jjMoveStringLiteralDfa1_1(0x10000000L);
100 default :
101 return jjMoveNfa_1(0, 0);
102 }
103 }
104 private final int jjMoveStringLiteralDfa1_1(long active0)
105 {
106 try { curChar = input_stream.readChar(); }
107 catch(java.io.IOException e) {
108 jjStopStringLiteralDfa_1(0, active0);
109 return 1;
110 }
111 switch(curChar)
112 {
113 case 67:
114 case 99:
115 return jjMoveStringLiteralDfa2_1(active0, 0x400000L);
116 case 79:
117 case 111:
118 return jjMoveStringLiteralDfa2_1(active0, 0x10000000L);
119 default :
120 break;
121 }
122 return jjStartNfa_1(0, active0);
123 }
124 private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
125 {
126 if (((active0 &= old0)) == 0L)
127 return jjStartNfa_1(0, old0);
128 try { curChar = input_stream.readChar(); }
129 catch(java.io.IOException e) {
130 jjStopStringLiteralDfa_1(1, active0);
131 return 2;
132 }
133 switch(curChar)
134 {
135 case 84:
136 case 116:
137 if ((active0 & 0x10000000L) != 0L)
138 return jjStartNfaWithStates_1(2, 28, 12);
139 return jjMoveStringLiteralDfa3_1(active0, 0x400000L);
140 default :
141 break;
142 }
143 return jjStartNfa_1(1, active0);
144 }
145 private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
146 {
147 if (((active0 &= old0)) == 0L)
148 return jjStartNfa_1(1, old0);
149 try { curChar = input_stream.readChar(); }
150 catch(java.io.IOException e) {
151 jjStopStringLiteralDfa_1(2, active0);
152 return 3;
153 }
154 switch(curChar)
155 {
156 case 73:
157 case 105:
158 return jjMoveStringLiteralDfa4_1(active0, 0x400000L);
159 default :
160 break;
161 }
162 return jjStartNfa_1(2, active0);
163 }
164 private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
165 {
166 if (((active0 &= old0)) == 0L)
167 return jjStartNfa_1(2, old0);
168 try { curChar = input_stream.readChar(); }
169 catch(java.io.IOException e) {
170 jjStopStringLiteralDfa_1(3, active0);
171 return 4;
172 }
173 switch(curChar)
174 {
175 case 79:
176 case 111:
177 return jjMoveStringLiteralDfa5_1(active0, 0x400000L);
178 default :
179 break;
180 }
181 return jjStartNfa_1(3, active0);
182 }
183 private final int jjMoveStringLiteralDfa5_1(long old0, long active0)
184 {
185 if (((active0 &= old0)) == 0L)
186 return jjStartNfa_1(3, old0);
187 try { curChar = input_stream.readChar(); }
188 catch(java.io.IOException e) {
189 jjStopStringLiteralDfa_1(4, active0);
190 return 5;
191 }
192 switch(curChar)
193 {
194 case 78:
195 case 110:
196 if ((active0 & 0x400000L) != 0L)
197 return jjStartNfaWithStates_1(5, 22, 12);
198 break;
199 default :
200 break;
201 }
202 return jjStartNfa_1(4, active0);
203 }
204 private final void jjCheckNAdd(int state)
205 {
206 if (jjrounds[state] != jjround)
207 {
208 jjstateSet[jjnewStateCnt++] = state;
209 jjrounds[state] = jjround;
210 }
211 }
212 private final void jjAddStates(int start, int end)
213 {
214 do {
215 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
216 } while (start++ != end);
217 }
218 private final void jjCheckNAddTwoStates(int state1, int state2)
219 {
220 jjCheckNAdd(state1);
221 jjCheckNAdd(state2);
222 }
223 private final void jjCheckNAddStates(int start, int end)
224 {
225 do {
226 jjCheckNAdd(jjnextStates[start]);
227 } while (start++ != end);
228 }
229 private final void jjCheckNAddStates(int start)
230 {
231 jjCheckNAdd(jjnextStates[start]);
232 jjCheckNAdd(jjnextStates[start + 1]);
233 }
234 static final long[] jjbitVec0 = {
235 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
236 };
237 private final int jjMoveNfa_1(int startState, int curPos)
238 {
239 int[] nextStates;
240 int startsAt = 0;
241 jjnewStateCnt = 57;
242 int i = 1;
243 jjstateSet[0] = startState;
244 int j, kind = 0x7fffffff;
245 for (;;)
246 {
247 if (++jjround == 0x7fffffff)
248 ReInitRounds();
249 if (curChar < 64)
250 {
251 long l = 1L << curChar;
252 MatchLoop: do
253 {
254 switch(jjstateSet[--i])
255 {
256 case 0:
257 if ((0x7800dcf200000000L & l) != 0L)
258 {
259 if (kind > 31)
260 kind = 31;
261 jjCheckNAdd(12);
262 }
263 else if (curChar == 34)
264 jjCheckNAddStates(0, 2);
265 if ((0xac2000000000L & l) != 0L)
266 {
267 if (kind > 25)
268 kind = 25;
269 }
270 else if (curChar == 59)
271 {
272 if (kind > 27)
273 kind = 27;
274 }
275 break;
276 case 42:
277 case 12:
278 if ((0xfffffcfa00000000L & l) == 0L)
279 break;
280 if (kind > 31)
281 kind = 31;
282 jjCheckNAdd(12);
283 break;
284 case 3:
285 if ((0xac2000000000L & l) != 0L && kind > 25)
286 kind = 25;
287 break;
288 case 8:
289 if (curChar == 59 && kind > 27)
290 kind = 27;
291 break;
292 case 11:
293 if ((0x7800dcf200000000L & l) == 0L)
294 break;
295 if (kind > 31)
296 kind = 31;
297 jjCheckNAdd(12);
298 break;
299 case 13:
300 case 15:
301 if (curChar == 34)
302 jjCheckNAddStates(0, 2);
303 break;
304 case 14:
305 if ((0xfffffffbffffffffL & l) != 0L)
306 jjCheckNAddStates(0, 2);
307 break;
308 case 17:
309 if (curChar == 34 && kind > 32)
310 kind = 32;
311 break;
312 default : break;
313 }
314 } while(i != startsAt);
315 }
316 else if (curChar < 128)
317 {
318 long l = 1L << (curChar & 077);
319 MatchLoop: do
320 {
321 switch(jjstateSet[--i])
322 {
323 case 0:
324 if (kind > 31)
325 kind = 31;
326 jjCheckNAdd(12);
327 if ((0x20020400200204L & l) != 0L)
328 {
329 if (kind > 24)
330 kind = 24;
331 }
332 else if ((0x2000000020L & l) != 0L)
333 jjAddStates(3, 4);
334 else if ((0x200000002L & l) != 0L)
335 jjAddStates(5, 7);
336 else if ((0x4000000040L & l) != 0L)
337 jjAddStates(8, 9);
338 else if ((0x800000008000L & l) != 0L)
339 jjstateSet[jjnewStateCnt++] = 9;
340 else if ((0x1000000010L & l) != 0L)
341 jjstateSet[jjnewStateCnt++] = 6;
342 else if ((0x1000000010000L & l) != 0L)
343 jjstateSet[jjnewStateCnt++] = 1;
344 else if (curChar == 124)
345 {
346 if (kind > 27)
347 kind = 27;
348 }
349 if ((0x20000000200L & l) != 0L)
350 jjAddStates(10, 11);
351 break;
352 case 42:
353 if (kind > 31)
354 kind = 31;
355 jjCheckNAdd(12);
356 if ((0x400000004000L & l) != 0L)
357 jjstateSet[jjnewStateCnt++] = 45;
358 else if ((0x100000001000L & l) != 0L)
359 jjstateSet[jjnewStateCnt++] = 43;
360 if ((0x400000004000L & l) != 0L)
361 jjstateSet[jjnewStateCnt++] = 41;
362 break;
363 case 1:
364 if ((0x8000000080L & l) != 0L && kind > 24)
365 kind = 24;
366 break;
367 case 2:
368 if ((0x1000000010000L & l) != 0L)
369 jjstateSet[jjnewStateCnt++] = 1;
370 break;
371 case 4:
372 if ((0x2000000020L & l) != 0L && kind > 26)
373 kind = 26;
374 break;
375 case 5:
376 if ((0x400000004000L & l) != 0L)
377 jjCheckNAdd(4);
378 break;
379 case 6:
380 if ((0x800000008000L & l) != 0L)
381 jjstateSet[jjnewStateCnt++] = 5;
382 break;
383 case 7:
384 if ((0x1000000010L & l) != 0L)
385 jjstateSet[jjnewStateCnt++] = 6;
386 break;
387 case 8:
388 if (curChar == 124 && kind > 27)
389 kind = 27;
390 break;
391 case 9:
392 if ((0x4000000040000L & l) != 0L && kind > 29)
393 kind = 29;
394 break;
395 case 10:
396 if ((0x800000008000L & l) != 0L)
397 jjstateSet[jjnewStateCnt++] = 9;
398 break;
399 case 11:
400 if (kind > 31)
401 kind = 31;
402 jjCheckNAdd(12);
403 break;
404 case 12:
405 if (kind > 31)
406 kind = 31;
407 jjCheckNAdd(12);
408 break;
409 case 14:
410 jjAddStates(0, 2);
411 break;
412 case 16:
413 if (curChar == 92)
414 jjstateSet[jjnewStateCnt++] = 15;
415 break;
416 case 18:
417 if ((0x20000000200L & l) != 0L)
418 jjAddStates(10, 11);
419 break;
420 case 19:
421 if ((0x200000002L & l) != 0L && kind > 23)
422 kind = 23;
423 break;
424 case 20:
425 if ((0x10000000100000L & l) != 0L)
426 jjstateSet[jjnewStateCnt++] = 19;
427 break;
428 case 21:
429 if ((0x800000008000L & l) != 0L)
430 jjstateSet[jjnewStateCnt++] = 20;
431 break;
432 case 22:
433 if ((0x8000000080000L & l) != 0L && kind > 29)
434 kind = 29;
435 break;
436 case 23:
437 if ((0x2000000020L & l) != 0L)
438 jjstateSet[jjnewStateCnt++] = 22;
439 break;
440 case 24:
441 if ((0x20000000200L & l) != 0L)
442 jjstateSet[jjnewStateCnt++] = 23;
443 break;
444 case 25:
445 if ((0x100000001000L & l) != 0L)
446 jjstateSet[jjnewStateCnt++] = 24;
447 break;
448 case 26:
449 if ((0x1000000010000L & l) != 0L)
450 jjstateSet[jjnewStateCnt++] = 25;
451 break;
452 case 27:
453 if ((0x200000002000L & l) != 0L)
454 jjstateSet[jjnewStateCnt++] = 26;
455 break;
456 case 28:
457 if ((0x4000000040L & l) != 0L)
458 jjAddStates(8, 9);
459 break;
460 case 29:
461 if ((0x100000001000L & l) != 0L)
462 jjCheckNAdd(4);
463 break;
464 case 30:
465 if ((0x400000004L & l) != 0L)
466 jjstateSet[jjnewStateCnt++] = 29;
467 break;
468 case 31:
469 if ((0x20000000200L & l) != 0L)
470 jjstateSet[jjnewStateCnt++] = 30;
471 break;
472 case 32:
473 if ((0x8000000080000L & l) != 0L)
474 jjstateSet[jjnewStateCnt++] = 31;
475 break;
476 case 33:
477 if ((0x200000002L & l) != 0L)
478 jjstateSet[jjnewStateCnt++] = 32;
479 break;
480 case 34:
481 if ((0x2000000020L & l) != 0L)
482 jjstateSet[jjnewStateCnt++] = 33;
483 break;
484 case 35:
485 if ((0x100000001000L & l) != 0L && kind > 30)
486 kind = 30;
487 break;
488 case 36:
489 if ((0x100000001000L & l) != 0L)
490 jjstateSet[jjnewStateCnt++] = 35;
491 break;
492 case 37:
493 if ((0x200000002L & l) != 0L)
494 jjstateSet[jjnewStateCnt++] = 36;
495 break;
496 case 38:
497 if ((0x4000000040000L & l) != 0L)
498 jjstateSet[jjnewStateCnt++] = 37;
499 break;
500 case 39:
501 if ((0x800000008000L & l) != 0L)
502 jjstateSet[jjnewStateCnt++] = 38;
503 break;
504 case 40:
505 if ((0x200000002L & l) != 0L)
506 jjAddStates(5, 7);
507 break;
508 case 41:
509 if ((0x200000002000000L & l) != 0L && kind > 23)
510 kind = 23;
511 break;
512 case 43:
513 if ((0x100000001000L & l) != 0L && kind > 23)
514 kind = 23;
515 break;
516 case 44:
517 if ((0x100000001000L & l) != 0L)
518 jjstateSet[jjnewStateCnt++] = 43;
519 break;
520 case 45:
521 if ((0x1000000010L & l) != 0L && kind > 29)
522 kind = 29;
523 break;
524 case 46:
525 if ((0x400000004000L & l) != 0L)
526 jjstateSet[jjnewStateCnt++] = 45;
527 break;
528 case 47:
529 if ((0x2000000020L & l) != 0L)
530 jjAddStates(3, 4);
531 break;
532 case 48:
533 if ((0x40000000400000L & l) != 0L && kind > 29)
534 kind = 29;
535 break;
536 case 49:
537 if ((0x20000000200L & l) != 0L)
538 jjstateSet[jjnewStateCnt++] = 48;
539 break;
540 case 50:
541 if ((0x20000000200000L & l) != 0L)
542 jjstateSet[jjnewStateCnt++] = 49;
543 break;
544 case 51:
545 if ((0x2000000020000L & l) != 0L)
546 jjstateSet[jjnewStateCnt++] = 50;
547 break;
548 case 52:
549 if ((0x8000000080000L & l) != 0L && kind > 30)
550 kind = 30;
551 break;
552 case 53:
553 if ((0x10000000100000L & l) != 0L)
554 jjstateSet[jjnewStateCnt++] = 52;
555 break;
556 case 54:
557 if ((0x8000000080000L & l) != 0L)
558 jjstateSet[jjnewStateCnt++] = 53;
559 break;
560 case 55:
561 if ((0x20000000200L & l) != 0L)
562 jjstateSet[jjnewStateCnt++] = 54;
563 break;
564 case 56:
565 if ((0x100000001000000L & l) != 0L)
566 jjstateSet[jjnewStateCnt++] = 55;
567 break;
568 default : break;
569 }
570 } while(i != startsAt);
571 }
572 else
573 {
574 int i2 = (curChar & 0xff) >> 6;
575 long l2 = 1L << (curChar & 077);
576 MatchLoop: do
577 {
578 switch(jjstateSet[--i])
579 {
580 case 0:
581 if ((jjbitVec0[i2] & l2) == 0L)
582 break;
583 if (kind > 31)
584 kind = 31;
585 jjCheckNAdd(12);
586 break;
587 case 42:
588 case 12:
589 if ((jjbitVec0[i2] & l2) == 0L)
590 break;
591 if (kind > 31)
592 kind = 31;
593 jjCheckNAdd(12);
594 break;
595 case 14:
596 if ((jjbitVec0[i2] & l2) != 0L)
597 jjAddStates(0, 2);
598 break;
599 default : break;
600 }
601 } while(i != startsAt);
602 }
603 if (kind != 0x7fffffff)
604 {
605 jjmatchedKind = kind;
606 jjmatchedPos = curPos;
607 kind = 0x7fffffff;
608 }
609 ++curPos;
610 if ((i = jjnewStateCnt) == (startsAt = 57 - (jjnewStateCnt = startsAt)))
611 return curPos;
612 try { curChar = input_stream.readChar(); }
613 catch(java.io.IOException e) { return curPos; }
614 }
615 }
616 private final int jjStopStringLiteralDfa_0(int pos, long active0)
617 {
618 switch (pos)
619 {
620 default :
621 return -1;
622 }
623 }
624 private final int jjStartNfa_0(int pos, long active0)
625 {
626 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
627 }
628 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
629 {
630 jjmatchedKind = kind;
631 jjmatchedPos = pos;
632 try { curChar = input_stream.readChar(); }
633 catch(java.io.IOException e) { return pos + 1; }
634 return jjMoveNfa_0(state, pos + 1);
635 }
636 private final int jjMoveStringLiteralDfa0_0()
637 {
638 switch(curChar)
639 {
640 case 40:
641 return jjStopAtPos(0, 5);
642 case 41:
643 return jjStopAtPos(0, 6);
644 default :
645 return jjMoveNfa_0(8, 0);
646 }
647 }
648 private final int jjMoveNfa_0(int startState, int curPos)
649 {
650 int[] nextStates;
651 int startsAt = 0;
652 jjnewStateCnt = 61;
653 int i = 1;
654 jjstateSet[0] = startState;
655 int j, kind = 0x7fffffff;
656 for (;;)
657 {
658 if (++jjround == 0x7fffffff)
659 ReInitRounds();
660 if (curChar < 64)
661 {
662 long l = 1L << curChar;
663 MatchLoop: do
664 {
665 switch(jjstateSet[--i])
666 {
667 case 8:
668 if ((0x7800dcf200000000L & l) != 0L)
669 {
670 if (kind > 12)
671 kind = 12;
672 jjCheckNAdd(9);
673 }
674 else if ((0x3ff000000000000L & l) != 0L)
675 {
676 if (kind > 8)
677 kind = 8;
678 jjCheckNAddStates(12, 19);
679 }
680 else if (curChar == 58)
681 jjAddStates(20, 21);
682 else if (curChar == 34)
683 jjCheckNAddStates(22, 24);
684 else if (curChar == 63)
685 jjAddStates(25, 26);
686 if ((0x280000000000L & l) != 0L)
687 jjCheckNAddStates(27, 31);
688 else if (curChar == 46)
689 jjCheckNAdd(4);
690 else if (curChar == 48)
691 jjstateSet[jjnewStateCnt++] = 1;
692 break;
693 case 0:
694 if (curChar == 48)
695 jjstateSet[jjnewStateCnt++] = 1;
696 break;
697 case 2:
698 if ((0x3ff000000000000L & l) == 0L)
699 break;
700 if (kind > 9)
701 kind = 9;
702 jjstateSet[jjnewStateCnt++] = 2;
703 break;
704 case 3:
705 if (curChar == 46)
706 jjCheckNAdd(4);
707 break;
708 case 4:
709 if ((0x3ff000000000000L & l) == 0L)
710 break;
711 if (kind > 10)
712 kind = 10;
713 jjCheckNAddTwoStates(4, 5);
714 break;
715 case 6:
716 if ((0x280000000000L & l) != 0L)
717 jjCheckNAdd(7);
718 break;
719 case 7:
720 if ((0x3ff000000000000L & l) == 0L)
721 break;
722 if (kind > 10)
723 kind = 10;
724 jjCheckNAdd(7);
725 break;
726 case 9:
727 if ((0xfffffcfa00000000L & l) == 0L)
728 break;
729 if (kind > 12)
730 kind = 12;
731 jjCheckNAdd(9);
732 break;
733 case 10:
734 case 12:
735 if (curChar == 34)
736 jjCheckNAddStates(22, 24);
737 break;
738 case 11:
739 if ((0xfffffffbffffffffL & l) != 0L)
740 jjCheckNAddStates(22, 24);
741 break;
742 case 14:
743 if (curChar == 34 && kind > 13)
744 kind = 13;
745 break;
746 case 15:
747 if (curChar == 58)
748 jjAddStates(20, 21);
749 break;
750 case 16:
751 if ((0x7800dcf200000000L & l) == 0L)
752 break;
753 if (kind > 14)
754 kind = 14;
755 jjCheckNAdd(17);
756 break;
757 case 17:
758 if ((0xfffffcfa00000000L & l) == 0L)
759 break;
760 if (kind > 14)
761 kind = 14;
762 jjCheckNAdd(17);
763 break;
764 case 18:
765 case 20:
766 if (curChar == 34)
767 jjCheckNAddStates(32, 34);
768 break;
769 case 19:
770 if ((0xfffffffbffffffffL & l) != 0L)
771 jjCheckNAddStates(32, 34);
772 break;
773 case 22:
774 if (curChar == 34 && kind > 14)
775 kind = 14;
776 break;
777 case 23:
778 if (curChar == 63)
779 jjAddStates(25, 26);
780 break;
781 case 24:
782 if ((0x7800dcf200000000L & l) == 0L)
783 break;
784 if (kind > 7)
785 kind = 7;
786 jjCheckNAdd(25);
787 break;
788 case 25:
789 if ((0xfffffcfa00000000L & l) == 0L)
790 break;
791 if (kind > 7)
792 kind = 7;
793 jjCheckNAdd(25);
794 break;
795 case 26:
796 case 28:
797 if (curChar == 34)
798 jjCheckNAddStates(35, 37);
799 break;
800 case 27:
801 if ((0xfffffffbffffffffL & l) != 0L)
802 jjCheckNAddStates(35, 37);
803 break;
804 case 30:
805 if (curChar == 34 && kind > 7)
806 kind = 7;
807 break;
808 case 31:
809 if ((0x280000000000L & l) != 0L)
810 jjCheckNAddStates(27, 31);
811 break;
812 case 32:
813 if ((0x3ff000000000000L & l) == 0L)
814 break;
815 if (kind > 8)
816 kind = 8;
817 jjCheckNAdd(32);
818 break;
819 case 33:
820 if ((0x3ff000000000000L & l) != 0L)
821 jjCheckNAddTwoStates(33, 34);
822 break;
823 case 35:
824 if ((0x280000000000L & l) != 0L)
825 jjCheckNAdd(36);
826 break;
827 case 36:
828 if ((0x3ff000000000000L & l) == 0L)
829 break;
830 if (kind > 11)
831 kind = 11;
832 jjCheckNAdd(36);
833 break;
834 case 37:
835 if ((0x3ff000000000000L & l) != 0L)
836 jjCheckNAddStates(38, 41);
837 break;
838 case 38:
839 if ((0x3ff000000000000L & l) != 0L)
840 jjCheckNAddTwoStates(38, 39);
841 break;
842 case 39:
843 if (curChar != 46)
844 break;
845 if (kind > 10)
846 kind = 10;
847 jjCheckNAddTwoStates(40, 5);
848 break;
849 case 40:
850 if ((0x3ff000000000000L & l) == 0L)
851 break;
852 if (kind > 10)
853 kind = 10;
854 jjCheckNAddTwoStates(40, 5);
855 break;
856 case 41:
857 if ((0x3ff000000000000L & l) != 0L)
858 jjCheckNAddTwoStates(41, 3);
859 break;
860 case 42:
861 if ((0x3ff000000000000L & l) == 0L)
862 break;
863 if (kind > 8)
864 kind = 8;
865 jjCheckNAddStates(12, 19);
866 break;
867 case 43:
868 if ((0x3ff000000000000L & l) != 0L)
869 jjstateSet[jjnewStateCnt++] = 44;
870 break;
871 case 44:
872 if ((0x3ff000000000000L & l) != 0L)
873 jjstateSet[jjnewStateCnt++] = 45;
874 break;
875 case 45:
876 if ((0x3ff000000000000L & l) != 0L)
877 jjstateSet[jjnewStateCnt++] = 46;
878 break;
879 case 46:
880 if ((0x3ff000000000000L & l) != 0L)
881 jjstateSet[jjnewStateCnt++] = 47;
882 break;
883 case 47:
884 if ((0x3ff000000000000L & l) != 0L)
885 jjstateSet[jjnewStateCnt++] = 48;
886 break;
887 case 48:
888 if ((0x3ff000000000000L & l) != 0L)
889 jjstateSet[jjnewStateCnt++] = 49;
890 break;
891 case 49:
892 if ((0x3ff000000000000L & l) != 0L)
893 jjstateSet[jjnewStateCnt++] = 50;
894 break;
895 case 51:
896 if ((0x3ff000000000000L & l) != 0L)
897 jjstateSet[jjnewStateCnt++] = 52;
898 break;
899 case 52:
900 if ((0x3ff000000000000L & l) != 0L)
901 jjstateSet[jjnewStateCnt++] = 53;
902 break;
903 case 53:
904 if ((0x3ff000000000000L & l) != 0L)
905 jjstateSet[jjnewStateCnt++] = 54;
906 break;
907 case 54:
908 if ((0x3ff000000000000L & l) != 0L)
909 jjstateSet[jjnewStateCnt++] = 55;
910 break;
911 case 55:
912 if ((0x3ff000000000000L & l) != 0L)
913 jjstateSet[jjnewStateCnt++] = 56;
914 break;
915 case 56:
916 if ((0x3ff000000000000L & l) != 0L)
917 jjstateSet[jjnewStateCnt++] = 57;
918 break;
919 case 57:
920 if ((0x3ff000000000000L & l) != 0L)
921 jjstateSet[jjnewStateCnt++] = 58;
922 break;
923 case 58:
924 if ((0x3ff000000000000L & l) != 0L)
925 jjstateSet[jjnewStateCnt++] = 59;
926 break;
927 case 59:
928 if ((0x3ff000000000000L & l) == 0L)
929 break;
930 if (kind > 15)
931 kind = 15;
932 jjstateSet[jjnewStateCnt++] = 60;
933 break;
934 default : break;
935 }
936 } while(i != startsAt);
937 }
938 else if (curChar < 128)
939 {
940 long l = 1L << (curChar & 077);
941 MatchLoop: do
942 {
943 switch(jjstateSet[--i])
944 {
945 case 8:
946 case 9:
947 if (kind > 12)
948 kind = 12;
949 jjCheckNAdd(9);
950 break;
951 case 1:
952 if ((0x100000001000000L & l) != 0L)
953 jjCheckNAdd(2);
954 break;
955 case 2:
956 if ((0x7e0000007eL & l) == 0L)
957 break;
958 if (kind > 9)
959 kind = 9;
960 jjCheckNAdd(2);
961 break;
962 case 5:
963 if ((0x2000000020L & l) != 0L)
964 jjAddStates(42, 43);
965 break;
966 case 11:
967 jjAddStates(22, 24);
968 break;
969 case 13:
970 if (curChar == 92)
971 jjstateSet[jjnewStateCnt++] = 12;
972 break;
973 case 16:
974 case 17:
975 if (kind > 14)
976 kind = 14;
977 jjCheckNAdd(17);
978 break;
979 case 19:
980 jjAddStates(32, 34);
981 break;
982 case 21:
983 if (curChar == 92)
984 jjstateSet[jjnewStateCnt++] = 20;
985 break;
986 case 24:
987 case 25:
988 if (kind > 7)
989 kind = 7;
990 jjCheckNAdd(25);
991 break;
992 case 27:
993 jjAddStates(35, 37);
994 break;
995 case 29:
996 if (curChar == 92)
997 jjstateSet[jjnewStateCnt++] = 28;
998 break;
999 case 34:
1000 if ((0x2000000020L & l) != 0L)
1001 jjAddStates(44, 45);
1002 break;
1003 case 50:
1004 if ((0x10000000100000L & l) != 0L)
1005 jjstateSet[jjnewStateCnt++] = 51;
1006 break;
1007 case 60:
1008 if ((0x7fffffe07fffffeL & l) != 0L && kind > 15)
1009 kind = 15;
1010 break;
1011 default : break;
1012 }
1013 } while(i != startsAt);
1014 }
1015 else
1016 {
1017 int i2 = (curChar & 0xff) >> 6;
1018 long l2 = 1L << (curChar & 077);
1019 MatchLoop: do
1020 {
1021 switch(jjstateSet[--i])
1022 {
1023 case 8:
1024 case 9:
1025 if ((jjbitVec0[i2] & l2) == 0L)
1026 break;
1027 if (kind > 12)
1028 kind = 12;
1029 jjCheckNAdd(9);
1030 break;
1031 case 11:
1032 if ((jjbitVec0[i2] & l2) != 0L)
1033 jjAddStates(22, 24);
1034 break;
1035 case 16:
1036 case 17:
1037 if ((jjbitVec0[i2] & l2) == 0L)
1038 break;
1039 if (kind > 14)
1040 kind = 14;
1041 jjCheckNAdd(17);
1042 break;
1043 case 19:
1044 if ((jjbitVec0[i2] & l2) != 0L)
1045 jjAddStates(32, 34);
1046 break;
1047 case 24:
1048 case 25:
1049 if ((jjbitVec0[i2] & l2) == 0L)
1050 break;
1051 if (kind > 7)
1052 kind = 7;
1053 jjCheckNAdd(25);
1054 break;
1055 case 27:
1056 if ((jjbitVec0[i2] & l2) != 0L)
1057 jjAddStates(35, 37);
1058 break;
1059 default : break;
1060 }
1061 } while(i != startsAt);
1062 }
1063 if (kind != 0x7fffffff)
1064 {
1065 jjmatchedKind = kind;
1066 jjmatchedPos = curPos;
1067 kind = 0x7fffffff;
1068 }
1069 ++curPos;
1070 if ((i = jjnewStateCnt) == (startsAt = 61 - (jjnewStateCnt = startsAt)))
1071 return curPos;
1072 try { curChar = input_stream.readChar(); }
1073 catch(java.io.IOException e) { return curPos; }
1074 }
1075 }
1076 static final int[] jjnextStates = {
1077 14, 16, 17, 51, 56, 42, 44, 46, 34, 39, 21, 27, 32, 38, 39, 41,
1078 3, 33, 34, 43, 16, 18, 11, 13, 14, 24, 26, 32, 0, 3, 33, 37,
1079 19, 21, 22, 27, 29, 30, 38, 39, 41, 3, 6, 7, 35, 36,
1080 };
1081 public static final String[] jjstrLiteralImages = {
1082 "", null, null, null, null, "\50", "\51", null, null, null, null, null, null,
1083 null, null, null, null, null, null, null, "\50", "\51", null, null, null, null, null,
1084 null, null, null, null, null, null, };
1085 public static final String[] lexStateNames = {
1086 "DEFAULT",
1087 "OPERATORSTATE",
1088 };
1089 public static final int[] jjnewLexState = {
1090 -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0,
1091 0, 0, 0, 0, 0, 0, 0, 0,
1092 };
1093 static final long[] jjtoToken = {
1094 0x1fff0ffe1L,
1095 };
1096 static final long[] jjtoSkip = {
1097 0xf001eL,
1098 };
1099 private ASCII_CharStream input_stream;
1100 private final int[] jjrounds = new int[61];
1101 private final int[] jjstateSet = new int[122];
1102 protected char curChar;
1103 public SLParserTokenManager(ASCII_CharStream stream)
1104 {
1105 if (ASCII_CharStream.staticFlag)
1106 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1107 input_stream = stream;
1108 }
1109 public SLParserTokenManager(ASCII_CharStream stream, int lexState)
1110 {
1111 this(stream);
1112 SwitchTo(lexState);
1113 }
1114 public void ReInit(ASCII_CharStream stream)
1115 {
1116 jjmatchedPos = jjnewStateCnt = 0;
1117 curLexState = defaultLexState;
1118 input_stream = stream;
1119 ReInitRounds();
1120 }
1121 private final void ReInitRounds()
1122 {
1123 int i;
1124 jjround = 0x80000001;
1125 for (i = 61; i-- > 0;)
1126 jjrounds[i] = 0x80000000;
1127 }
1128 public void ReInit(ASCII_CharStream stream, int lexState)
1129 {
1130 ReInit(stream);
1131 SwitchTo(lexState);
1132 }
1133 public void SwitchTo(int lexState)
1134 {
1135 if (lexState >= 2 || lexState < 0)
1136 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1137 else
1138 curLexState = lexState;
1139 }
1140
1141 private final Token jjFillToken()
1142 {
1143 Token t = Token.newToken(jjmatchedKind);
1144 t.kind = jjmatchedKind;
1145 String im = jjstrLiteralImages[jjmatchedKind];
1146 t.image = (im == null) ? input_stream.GetImage() : im;
1147 t.beginLine = input_stream.getBeginLine();
1148 t.beginColumn = input_stream.getBeginColumn();
1149 t.endLine = input_stream.getEndLine();
1150 t.endColumn = input_stream.getEndColumn();
1151 return t;
1152 }
1153
1154 int curLexState = 0;
1155 int defaultLexState = 0;
1156 int jjnewStateCnt;
1157 int jjround;
1158 int jjmatchedPos;
1159 int jjmatchedKind;
1160
1161 public final Token getNextToken()
1162 {
1163 int kind;
1164 Token specialToken = null;
1165 Token matchedToken;
1166 int curPos = 0;
1167
1168 EOFLoop :
1169 for (;;)
1170 {
1171 try
1172 {
1173 curChar = input_stream.BeginToken();
1174 }
1175 catch(java.io.IOException e)
1176 {
1177 jjmatchedKind = 0;
1178 matchedToken = jjFillToken();
1179 return matchedToken;
1180 }
1181
1182 switch(curLexState)
1183 {
1184 case 0:
1185 try { input_stream.backup(0);
1186 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
1187 curChar = input_stream.BeginToken();
1188 }
1189 catch (java.io.IOException e1) { continue EOFLoop; }
1190 jjmatchedKind = 0x7fffffff;
1191 jjmatchedPos = 0;
1192 curPos = jjMoveStringLiteralDfa0_0();
1193 break;
1194 case 1:
1195 try { input_stream.backup(0);
1196 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
1197 curChar = input_stream.BeginToken();
1198 }
1199 catch (java.io.IOException e1) { continue EOFLoop; }
1200 jjmatchedKind = 0x7fffffff;
1201 jjmatchedPos = 0;
1202 curPos = jjMoveStringLiteralDfa0_1();
1203 break;
1204 }
1205 if (jjmatchedKind != 0x7fffffff)
1206 {
1207 if (jjmatchedPos + 1 < curPos)
1208 input_stream.backup(curPos - jjmatchedPos - 1);
1209 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1210 {
1211 matchedToken = jjFillToken();
1212 if (jjnewLexState[jjmatchedKind] != -1)
1213 curLexState = jjnewLexState[jjmatchedKind];
1214 return matchedToken;
1215 }
1216 else
1217 {
1218 if (jjnewLexState[jjmatchedKind] != -1)
1219 curLexState = jjnewLexState[jjmatchedKind];
1220 continue EOFLoop;
1221 }
1222 }
1223 int error_line = input_stream.getEndLine();
1224 int error_column = input_stream.getEndColumn();
1225 String error_after = null;
1226 boolean EOFSeen = false;
1227 try { input_stream.readChar(); input_stream.backup(1); }
1228 catch (java.io.IOException e1) {
1229 EOFSeen = true;
1230 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1231 if (curChar == '\n' || curChar == '\r') {
1232 error_line++;
1233 error_column = 0;
1234 }
1235 else
1236 error_column++;
1237 }
1238 if (!EOFSeen) {
1239 input_stream.backup(1);
1240 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1241 }
1242 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1243 }
1244 }
1245
1246 }