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