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