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