|
1
2 package org.nfunk.jep;
3 import java.util.Vector  ;
4 import org.nfunk.jep.function.*;
5 import org.nfunk.jep.type.*;
6
7 public class ParserTokenManager implements ParserConstants
8 {
9 public java.io.PrintStream debugStream = System.out;
10 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
11 private final int jjStopStringLiteralDfa_1(int pos, long active0)
12 {
13 switch (pos)
14 {
15 case 0:
16 if ((active0 & 0x100000000L) != 0L)
17 return 1;
18 if ((active0 & 0x200000000L) != 0L)
19 return 13;
20 return -1;
21 default :
22 return -1;
23 }
24 }
25 private final int jjStartNfa_1(int pos, long active0)
26 {
27 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
28 }
29 private final int jjStopAtPos(int pos, int kind)
30 {
31 jjmatchedKind = kind;
32 jjmatchedPos = pos;
33 return pos + 1;
34 }
35 private final int jjStartNfaWithStates_1(int pos, int kind, int state)
36 {
37 jjmatchedKind = kind;
38 jjmatchedPos = pos;
39 try { curChar = input_stream.readChar(); }
40 catch(java.io.IOException e) { return pos + 1; }
41 return jjMoveNfa_1(state, pos + 1);
42 }
43 private final int jjMoveStringLiteralDfa0_1()
44 {
45 switch(curChar)
46 {
47 case 33:
48 jjmatchedKind = 35;
49 return jjMoveStringLiteralDfa1_1(0x4000000L);
50 case 37:
51 return jjStopAtPos(0, 34);
52 case 38:
53 return jjMoveStringLiteralDfa1_1(0x8000000L);
54 case 40:
55 return jjStopAtPos(0, 40);
56 case 41:
57 return jjStopAtPos(0, 41);
58 case 42:
59 return jjStopAtPos(0, 31);
60 case 43:
61 return jjStopAtPos(0, 29);
62 case 44:
63 return jjStopAtPos(0, 20);
64 case 45:
65 return jjStopAtPos(0, 30);
66 case 46:
67 return jjStartNfaWithStates_1(0, 32, 1);
68 case 47:
69 return jjStartNfaWithStates_1(0, 33, 13);
70 case 59:
71 return jjStopAtPos(0, 19);
72 case 60:
73 jjmatchedKind = 22;
74 return jjMoveStringLiteralDfa1_1(0x1000000L);
75 case 61:
76 jjmatchedKind = 18;
77 return jjMoveStringLiteralDfa1_1(0x800000L);
78 case 62:
79 jjmatchedKind = 21;
80 return jjMoveStringLiteralDfa1_1(0x2000000L);
81 case 91:
82 return jjStopAtPos(0, 38);
83 case 93:
84 return jjStopAtPos(0, 39);
85 case 94:
86 jjmatchedKind = 36;
87 return jjMoveStringLiteralDfa1_1(0x2000000000L);
88 case 124:
89 return jjMoveStringLiteralDfa1_1(0x10000000L);
90 default :
91 return jjMoveNfa_1(0, 0);
92 }
93 }
94 private final int jjMoveStringLiteralDfa1_1(long active0)
95 {
96 try { curChar = input_stream.readChar(); }
97 catch(java.io.IOException e) {
98 jjStopStringLiteralDfa_1(0, active0);
99 return 1;
100 }
101 switch(curChar)
102 {
103 case 38:
104 if ((active0 & 0x8000000L) != 0L)
105 return jjStopAtPos(1, 27);
106 break;
107 case 61:
108 if ((active0 & 0x800000L) != 0L)
109 return jjStopAtPos(1, 23);
110 else if ((active0 & 0x1000000L) != 0L)
111 return jjStopAtPos(1, 24);
112 else if ((active0 & 0x2000000L) != 0L)
113 return jjStopAtPos(1, 25);
114 else if ((active0 & 0x4000000L) != 0L)
115 return jjStopAtPos(1, 26);
116 break;
117 case 94:
118 if ((active0 & 0x2000000000L) != 0L)
119 return jjStopAtPos(1, 37);
120 break;
121 case 124:
122 if ((active0 & 0x10000000L) != 0L)
123 return jjStopAtPos(1, 28);
124 break;
125 default :
126 break;
127 }
128 return jjStartNfa_1(0, active0);
129 }
130 private final void jjCheckNAdd(int state)
131 {
132 if (jjrounds[state] != jjround)
133 {
134 jjstateSet[jjnewStateCnt++] = state;
135 jjrounds[state] = jjround;
136 }
137 }
138 private final void jjAddStates(int start, int end)
139 {
140 do {
141 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
142 } while (start++ != end);
143 }
144 private final void jjCheckNAddTwoStates(int state1, int state2)
145 {
146 jjCheckNAdd(state1);
147 jjCheckNAdd(state2);
148 }
149 private final void jjCheckNAddStates(int start, int end)
150 {
151 do {
152 jjCheckNAdd(jjnextStates[start]);
153 } while (start++ != end);
154 }
155 private final void jjCheckNAddStates(int start)
156 {
157 jjCheckNAdd(jjnextStates[start]);
158 jjCheckNAdd(jjnextStates[start + 1]);
159 }
160 static final long[] jjbitVec0 = {
161 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
162 };
163 static final long[] jjbitVec2 = {
164 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
165 };
166 static final long[] jjbitVec3 = {
167 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
168 };
169 static final long[] jjbitVec4 = {
170 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
171 };
172 static final long[] jjbitVec5 = {
173 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
174 };
175 static final long[] jjbitVec6 = {
176 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
177 };
178 static final long[] jjbitVec7 = {
179 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
180 };
181 static final long[] jjbitVec8 = {
182 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
183 };
184 private final int jjMoveNfa_1(int startState, int curPos)
185 {
186 int[] nextStates;
187 int startsAt = 0;
188 jjnewStateCnt = 36;
189 int i = 1;
190 jjstateSet[0] = startState;
191 int j, kind = 0x7fffffff;
192 for (;;)
193 {
194 if (++jjround == 0x7fffffff)
195 ReInitRounds();
196 if (curChar < 64)
197 {
198 long l = 1L << curChar;
199 MatchLoop: do
200 {
201 switch(jjstateSet[--i])
202 {
203 case 13:
204 if (curChar == 42)
205 jjCheckNAddTwoStates(19, 20);
206 else if (curChar == 47)
207 jjCheckNAddStates(0, 2);
208 break;
209 case 0:
210 if ((0x3ff000000000000L & l) != 0L)
211 {
212 if (kind > 7)
213 kind = 7;
214 jjCheckNAddStates(3, 7);
215 }
216 else if (curChar == 47)
217 jjAddStates(8, 9);
218 else if (curChar == 36)
219 {
220 if (kind > 12)
221 kind = 12;
222 jjCheckNAdd(11);
223 }
224 else if (curChar == 34)
225 jjCheckNAddStates(10, 12);
226 else if (curChar == 46)
227 jjCheckNAdd(1);
228 break;
229 case 1:
230 if ((0x3ff000000000000L & l) == 0L)
231 break;
232 if (kind > 9)
233 kind = 9;
234 jjCheckNAddTwoStates(1, 2);
235 break;
236 case 3:
237 if ((0x280000000000L & l) != 0L)
238 jjCheckNAdd(4);
239 break;
240 case 4:
241 if ((0x3ff000000000000L & l) == 0L)
242 break;
243 if (kind > 9)
244 kind = 9;
245 jjCheckNAdd(4);
246 break;
247 case 5:
248 if (curChar == 34)
249 jjCheckNAddStates(10, 12);
250 break;
251 case 6:
252 if ((0xfffffffbffffdbffL & l) != 0L)
253 jjCheckNAddStates(10, 12);
254 break;
255 case 8:
256 if ((0x8400000000L & l) != 0L)
257 jjCheckNAddStates(10, 12);
258 break;
259 case 9:
260 if (curChar == 34 && kind > 11)
261 kind = 11;
262 break;
263 case 10:
264 if (curChar != 36)
265 break;
266 if (kind > 12)
267 kind = 12;
268 jjCheckNAdd(11);
269 break;
270 case 11:
271 if ((0x3ff401000000000L & l) == 0L)
272 break;
273 if (kind > 12)
274 kind = 12;
275 jjCheckNAdd(11);
276 break;
277 case 12:
278 if (curChar == 47)
279 jjAddStates(8, 9);
280 break;
281 case 14:
282 if ((0xffffffffffffdbffL & l) != 0L)
283 jjCheckNAddStates(0, 2);
284 break;
285 case 15:
286 if ((0x2400L & l) != 0L && kind > 5)
287 kind = 5;
288 break;
289 case 16:
290 if (curChar == 10 && kind > 5)
291 kind = 5;
292 break;
293 case 17:
294 if (curChar == 13)
295 jjstateSet[jjnewStateCnt++] = 16;
296 break;
297 case 18:
298 if (curChar == 42)
299 jjCheckNAddTwoStates(19, 20);
300 break;
301 case 19:
302 if ((0xfffffbffffffffffL & l) != 0L)
303 jjCheckNAddTwoStates(19, 20);
304 break;
305 case 20:
306 if (curChar == 42)
307 jjAddStates(13, 14);
308 break;
309 case 21:
310 if ((0xffff7fffffffffffL & l) != 0L)
311 jjCheckNAddTwoStates(22, 20);
312 break;
313 case 22:
314 if ((0xfffffbffffffffffL & l) != 0L)
315 jjCheckNAddTwoStates(22, 20);
316 break;
317 case 23:
318 if (curChar == 47 && kind > 6)
319 kind = 6;
320 break;
321 case 24:
322 if ((0x3ff000000000000L & l) == 0L)
323 break;
324 if (kind > 7)
325 kind = 7;
326 jjCheckNAddStates(3, 7);
327 break;
328 case 25:
329 if ((0x3ff000000000000L & l) == 0L)
330 break;
331 if (kind > 7)
332 kind = 7;
333 jjCheckNAdd(25);
334 break;
335 case 26:
336 if ((0x3ff000000000000L & l) != 0L)
337 jjCheckNAddTwoStates(26, 27);
338 break;
339 case 27:
340 if (curChar != 46)
341 break;
342 if (kind > 9)
343 kind = 9;
344 jjCheckNAddTwoStates(28, 29);
345 break;
346 case 28:
347 if ((0x3ff000000000000L & l) == 0L)
348 break;
349 if (kind > 9)
350 kind = 9;
351 jjCheckNAddTwoStates(28, 29);
352 break;
353 case 30:
354 if ((0x280000000000L & l) != 0L)
355 jjCheckNAdd(31);
356 break;
357 case 31:
358 if ((0x3ff000000000000L & l) == 0L)
359 break;
360 if (kind > 9)
361 kind = 9;
362 jjCheckNAdd(31);
363 break;
364 case 32:
365 if ((0x3ff000000000000L & l) != 0L)
366 jjCheckNAddTwoStates(32, 33);
367 break;
368 case 34:
369 if ((0x280000000000L & l) != 0L)
370 jjCheckNAdd(35);
371 break;
372 case 35:
373 if ((0x3ff000000000000L & l) == 0L)
374 break;
375 if (kind > 9)
376 kind = 9;
377 jjCheckNAdd(35);
378 break;
379 default : break;
380 }
381 } while(i != startsAt);
382 }
383 else if (curChar < 128)
384 {
385 long l = 1L << (curChar & 077);
386 MatchLoop: do
387 {
388 switch(jjstateSet[--i])
389 {
390 case 0:
391 case 11:
392 if ((0x7fffffe87fffffeL & l) == 0L)
393 break;
394 if (kind > 12)
395 kind = 12;
396 jjCheckNAdd(11);
397 break;
398 case 2:
399 if ((0x2000000020L & l) != 0L)
400 jjAddStates(15, 16);
401 break;
402 case 6:
403 if ((0xffffffffefffffffL & l) != 0L)
404 jjCheckNAddStates(10, 12);
405 break;
406 case 7:
407 if (curChar == 92)
408 jjstateSet[jjnewStateCnt++] = 8;
409 break;
410 case 8:
411 if ((0x14404410000000L & l) != 0L)
412 jjCheckNAddStates(10, 12);
413 break;
414 case 14:
415 jjAddStates(0, 2);
416 break;
417 case 19:
418 jjCheckNAddTwoStates(19, 20);
419 break;
420 case 21:
421 case 22:
422 jjCheckNAddTwoStates(22, 20);
423 break;
424 case 29:
425 if ((0x2000000020L & l) != 0L)
426 jjAddStates(17, 18);
427 break;
428 case 33:
429 if ((0x2000000020L & l) != 0L)
430 jjAddStates(19, 20);
431 break;
432 default : break;
433 }
434 } while(i != startsAt);
435 }
436 else
437 {
438 int hiByte = (int)(curChar >> 8);
439 int i1 = hiByte >> 6;
440 long l1 = 1L << (hiByte & 077);
441 int i2 = (curChar & 0xff) >> 6;
442 long l2 = 1L << (curChar & 077);
443 MatchLoop: do
444 {
445 switch(jjstateSet[--i])
446 {
447 case 0:
448 case 11:
449 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
450 break;
451 if (kind > 12)
452 kind = 12;
453 jjCheckNAdd(11);
454 break;
455 case 6:
456 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
457 jjAddStates(10, 12);
458 break;
459 case 14:
460 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
461 jjAddStates(0, 2);
462 break;
463 case 19:
464 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
465 jjCheckNAddTwoStates(19, 20);
466 break;
467 case 21:
468 case 22:
469 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
470 jjCheckNAddTwoStates(22, 20);
471 break;
472 default : break;
473 }
474 } while(i != startsAt);
475 }
476 if (kind != 0x7fffffff)
477 {
478 jjmatchedKind = kind;
479 jjmatchedPos = curPos;
480 kind = 0x7fffffff;
481 }
482 ++curPos;
483 if ((i = jjnewStateCnt) == (startsAt = 36 - (jjnewStateCnt = startsAt)))
484 return curPos;
485 try { curChar = input_stream.readChar(); }
486 catch(java.io.IOException e) { return curPos; }
487 }
488 }
489 private final int jjStopStringLiteralDfa_0(int pos, long active0)
490 {
491 switch (pos)
492 {
493 case 0:
494 if ((active0 & 0x100000000L) != 0L)
495 return 1;
496 if ((active0 & 0x200000000L) != 0L)
497 return 13;
498 return -1;
499 default :
500 return -1;
501 }
502 }
503 private final int jjStartNfa_0(int pos, long active0)
504 {
505 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
506 }
507 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
508 {
509 jjmatchedKind = kind;
510 jjmatchedPos = pos;
511 try { curChar = input_stream.readChar(); }
512 catch(java.io.IOException e) { return pos + 1; }
513 return jjMoveNfa_0(state, pos + 1);
514 }
515 private final int jjMoveStringLiteralDfa0_0()
516 {
517 switch(curChar)
518 {
519 case 33:
520 jjmatchedKind = 35;
521 return jjMoveStringLiteralDfa1_0(0x4000000L);
522 case 37:
523 return jjStopAtPos(0, 34);
524 case 38:
525 return jjMoveStringLiteralDfa1_0(0x8000000L);
526 case 40:
527 return jjStopAtPos(0, 40);
528 case 41:
529 return jjStopAtPos(0, 41);
530 case 42:
531 return jjStopAtPos(0, 31);
532 case 43:
533 return jjStopAtPos(0, 29);
534 case 44:
535 return jjStopAtPos(0, 20);
536 case 45:
537 return jjStopAtPos(0, 30);
538 case 46:
539 return jjStartNfaWithStates_0(0, 32, 1);
540 case 47:
541 return jjStartNfaWithStates_0(0, 33, 13);
542 case 59:
543 return jjStopAtPos(0, 19);
544 case 60:
545 jjmatchedKind = 22;
546 return jjMoveStringLiteralDfa1_0(0x1000000L);
547 case 61:
548 jjmatchedKind = 18;
549 return jjMoveStringLiteralDfa1_0(0x800000L);
550 case 62:
551 jjmatchedKind = 21;
552 return jjMoveStringLiteralDfa1_0(0x2000000L);
553 case 91:
554 return jjStopAtPos(0, 38);
555 case 93:
556 return jjStopAtPos(0, 39);
557 case 94:
558 jjmatchedKind = 36;
559 return jjMoveStringLiteralDfa1_0(0x2000000000L);
560 case 124:
561 return jjMoveStringLiteralDfa1_0(0x10000000L);
562 default :
563 return jjMoveNfa_0(0, 0);
564 }
565 }
566 private final int jjMoveStringLiteralDfa1_0(long active0)
567 {
568 try { curChar = input_stream.readChar(); }
569 catch(java.io.IOException e) {
570 jjStopStringLiteralDfa_0(0, active0);
571 return 1;
572 }
573 switch(curChar)
574 {
575 case 38:
576 if ((active0 & 0x8000000L) != 0L)
577 return jjStopAtPos(1, 27);
578 break;
579 case 61:
580 if ((active0 & 0x800000L) != 0L)
581 return jjStopAtPos(1, 23);
582 else if ((active0 & 0x1000000L) != 0L)
583 return jjStopAtPos(1, 24);
584 else if ((active0 & 0x2000000L) != 0L)
585 return jjStopAtPos(1, 25);
586 else if ((active0 & 0x4000000L) != 0L)
587 return jjStopAtPos(1, 26);
588 break;
589 case 94:
590 if ((active0 & 0x2000000000L) != 0L)
591 return jjStopAtPos(1, 37);
592 break;
593 case 124:
594 if ((active0 & 0x10000000L) != 0L)
595 return jjStopAtPos(1, 28);
596 break;
597 default :
598 break;
599 }
600 return jjStartNfa_0(0, active0);
601 }
602 private final int jjMoveNfa_0(int startState, int curPos)
603 {
604 int[] nextStates;
605 int startsAt = 0;
606 jjnewStateCnt = 36;
607 int i = 1;
608 jjstateSet[0] = startState;
609 int j, kind = 0x7fffffff;
610 for (;;)
611 {
612 if (++jjround == 0x7fffffff)
613 ReInitRounds();
614 if (curChar < 64)
615 {
616 long l = 1L << curChar;
617 MatchLoop: do
618 {
619 switch(jjstateSet[--i])
620 {
621 case 13:
622 if (curChar == 42)
623 jjCheckNAddTwoStates(19, 20);
624 else if (curChar == 47)
625 jjCheckNAddStates(0, 2);
626 break;
627 case 0:
628 if ((0x3ff000000000000L & l) != 0L)
629 {
630 if (kind > 7)
631 kind = 7;
632 jjCheckNAddStates(3, 7);
633 }
634 else if (curChar == 47)
635 jjAddStates(8, 9);
636 else if (curChar == 36)
637 {
638 if (kind > 15)
639 kind = 15;
640 jjCheckNAdd(11);
641 }
642 else if (curChar == 34)
643 jjCheckNAddStates(10, 12);
644 else if (curChar == 46)
645 jjCheckNAdd(1);
646 break;
647 case 1:
648 if ((0x3ff000000000000L & l) == 0L)
649 break;
650 if (kind > 9)
651 kind = 9;
652 jjCheckNAddTwoStates(1, 2);
653 break;
654 case 3:
655 if ((0x280000000000L & l) != 0L)
656 jjCheckNAdd(4);
657 break;
658 case 4:
659 if ((0x3ff000000000000L & l) == 0L)
660 break;
661 if (kind > 9)
662 kind = 9;
663 jjCheckNAdd(4);
664 break;
665 case 5:
666 if (curChar == 34)
667 jjCheckNAddStates(10, 12);
668 break;
669 case 6:
670 if ((0xfffffffbffffdbffL & l) != 0L)
671 jjCheckNAddStates(10, 12);
672 break;
673 case 8:
674 if ((0x8400000000L & l) != 0L)
675 jjCheckNAddStates(10, 12);
676 break;
677 case 9:
678 if (curChar == 34 && kind > 11)
679 kind = 11;
680 break;
681 case 10:
682 if (curChar != 36)
683 break;
684 if (kind > 15)
685 kind = 15;
686 jjCheckNAdd(11);
687 break;
688 case 11:
689 if ((0x3ff001000000000L & l) == 0L)
690 break;
691 if (kind > 15)
692 kind = 15;
693
|
Java API By Example, From Geeks To Geeks.