|
1
2
3
25
26 package net.sourceforge.cobertura.javancss;
27
28 public class JavaParserTokenManager implements JavaParserConstants
29 {
30
31
33 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
34 {
35 switch (pos)
36 {
37 case 0:
38 if ((active1 & 0x100000L) != 0L)
39 return 4;
40 if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L)
41 {
42 jjmatchedKind = 73;
43 return 28;
44 }
45 return -1;
46 case 1:
47 if ((active0 & 0x806000000L) != 0L)
48 return 28;
49 if ((active0 & 0xfffffff7f9ffe000L) != 0L || (active1 & 0x1L) != 0L)
50 {
51 if (jjmatchedPos != 1)
52 {
53 jjmatchedKind = 73;
54 jjmatchedPos = 1;
55 }
56 return 28;
57 }
58 return -1;
59 case 2:
60 if ((active0 & 0x2000098200000000L) != 0L)
61 return 28;
62 if ((active0 & 0xdffff675fdffe000L) != 0L || (active1 & 0x1L) != 0L)
63 {
64 if (jjmatchedPos != 2)
65 {
66 jjmatchedKind = 73;
67 jjmatchedPos = 2;
68 }
69 return 28;
70 }
71 return -1;
72 case 3:
73 if ((active0 & 0x8effe571f5e9e000L) != 0L || (active1 & 0x1L) != 0L)
74 {
75 jjmatchedKind = 73;
76 jjmatchedPos = 3;
77 return 28;
78 }
79 if ((active0 & 0x5100120408160000L) != 0L)
80 return 28;
81 return -1;
82 case 4:
83 if ((active0 & 0x6240001e0690000L) != 0L || (active1 & 0x1L) != 0L)
84 return 28;
85 if ((active0 & 0x88dbe5701580e000L) != 0L)
86 {
87 if (jjmatchedPos != 4)
88 {
89 jjmatchedKind = 73;
90 jjmatchedPos = 4;
91 }
92 return 28;
93 }
94 return -1;
95 case 5:
96 if ((active0 & 0x44b042004004000L) != 0L)
97 return 28;
98 if ((active0 & 0x8890e1509180a000L) != 0L)
99 {
100 jjmatchedKind = 73;
101 jjmatchedPos = 5;
102 return 28;
103 }
104 return -1;
105 case 6:
106 if ((active0 & 0x8890815000802000L) != 0L)
107 {
108 jjmatchedKind = 73;
109 jjmatchedPos = 6;
110 return 28;
111 }
112 if ((active0 & 0x600091008000L) != 0L)
113 return 28;
114 return -1;
115 case 7:
116 if ((active0 & 0x8010000000802000L) != 0L)
117 return 28;
118 if ((active0 & 0x880815000000000L) != 0L)
119 {
120 jjmatchedKind = 73;
121 jjmatchedPos = 7;
122 return 28;
123 }
124 return -1;
125 case 8:
126 if ((active0 & 0x800810000000000L) != 0L)
127 return 28;
128 if ((active0 & 0x80005000000000L) != 0L)
129 {
130 jjmatchedKind = 73;
131 jjmatchedPos = 8;
132 return 28;
133 }
134 return -1;
135 case 9:
136 if ((active0 & 0x5000000000L) != 0L)
137 return 28;
138 if ((active0 & 0x80000000000000L) != 0L)
139 {
140 jjmatchedKind = 73;
141 jjmatchedPos = 9;
142 return 28;
143 }
144 return -1;
145 case 10:
146 if ((active0 & 0x80000000000000L) != 0L)
147 {
148 jjmatchedKind = 73;
149 jjmatchedPos = 10;
150 return 28;
151 }
152 return -1;
153 default:
154 return -1;
155 }
156 }
157
158 private final int jjStartNfa_0(int pos, long active0, long active1)
159 {
160 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
161 }
162
163 private final int jjStopAtPos(int pos, int kind)
164 {
165 jjmatchedKind = kind;
166 jjmatchedPos = pos;
167 return pos + 1;
168 }
169
170 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
171 {
172 jjmatchedKind = kind;
173 jjmatchedPos = pos;
174 try
175 {
176 curChar = input_stream.readChar();
177 }
178 catch (java.io.IOException  e)
179 {
180 return pos + 1;
181 }
182 return jjMoveNfa_0(state, pos + 1);
183 }
184
185 private final int jjMoveStringLiteralDfa0_0()
186 {
187 switch (curChar)
188 {
189 case 33:
190 jjmatchedKind = 88;
191 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
192 case 37:
193 jjmatchedKind = 107;
194 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
195 case 38:
196 jjmatchedKind = 104;
197 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L);
198 case 40:
199 return jjStopAtPos(0, 76);
200 case 41:
201 return jjStopAtPos(0, 77);
202 case 42:
203 jjmatchedKind = 102;
204 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
205 case 43:
206 jjmatchedKind = 100;
207 return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L);
208 case 44:
209 return jjStopAtPos(0, 83);
210 case 45:
211 jjmatchedKind = 101;
212 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000800000000L);
213 case 46:
214 return jjStartNfaWithStates_0(0, 84, 4);
215 case 47:
216 jjmatchedKind = 103;
217 return jjMoveStringLiteralDfa1_0(0x180L, 0x4000000000000L);
218 case 58:
219 return jjStopAtPos(0, 91);
220 case 59:
221 return jjStopAtPos(0, 82);
222 case 60:
223 jjmatchedKind = 87;
224 return jjMoveStringLiteralDfa1_0(0x0L, 0x80100020000000L);
225 case 61:
226 jjmatchedKind = 85;
227 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
228 case 62:
229 jjmatchedKind = 86;
230 return jjMoveStringLiteralDfa1_0(0x0L, 0x300600040000000L);
231 case 63:
232 return jjStopAtPos(0, 90);
233 case 91:
234 return jjStopAtPos(0, 80);
235 case 93:
236 return jjStopAtPos(0, 81);
237 case 94:
238 jjmatchedKind = 106;
239 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
240 case 97:
241 return jjMoveStringLiteralDfa1_0(0x6000L, 0x0L);
242 case 98:
243 return jjMoveStringLiteralDfa1_0(0x38000L, 0x0L);
244 case 99:
245 return jjMoveStringLiteralDfa1_0(0xfc0000L, 0x0L);
246 case 100:
247 return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L);
248 case 101:
249 return jjMoveStringLiteralDfa1_0(0x18000000L, 0x0L);
250 case 102:
251 return jjMoveStringLiteralDfa1_0(0x3e0000000L, 0x0L);
252 case 103:
253 return jjMoveStringLiteralDfa1_0(0x400000000L, 0x0L);
254 case 105:
255 return jjMoveStringLiteralDfa1_0(0x1f800000000L, 0x0L);
256 case 108:
257 return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L);
258 case 110:
259 return jjMoveStringLiteralDfa1_0(0x1c0000000000L, 0x0L);
260 case 112:
261 return jjMoveStringLiteralDfa1_0(0x1e00000000000L, 0x0L);
262 case 114:
263 return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L);
264 case 115:
265 return jjMoveStringLiteralDfa1_0(0xfc000000000000L, 0x0L);
266 case 116:
267 return jjMoveStringLiteralDfa1_0(0x3f00000000000000L, 0x0L);
268 case 118:
269 return jjMoveStringLiteralDfa1_0(0xc000000000000000L, 0x0L);
270 case 119:
271 return jjMoveStringLiteralDfa1_0(0x0L, 0x1L);
272 case 123:
273 return jjStopAtPos(0, 78);
274 case 124:
275 jjmatchedKind = 105;
276 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000100000000L);
277 case 125:
278 return jjStopAtPos(0, 79);
279 case 126:
280 return jjStopAtPos(0, 89);
281 default:
282 return jjMoveNfa_0(0, 0);
283 }
284 }
285
286 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
287 {
288 try
289 {
290 curChar = input_stream.readChar();
291 }
292 catch (java.io.IOException e)
293 {
294 jjStopStringLiteralDfa_0(0, active0, active1);
295 return 1;
296 }
297 switch (curChar)
298 {
299 case 38:
300 if ((active1 & 0x200000000L) != 0L)
301 return jjStopAtPos(1, 97);
302 break;
303 case 42:
304 if ((active0 & 0x80L) != 0L)
305 return jjStopAtPos(1, 7);
306 break;
307 case 43:
308 if ((active1 & 0x400000000L) != 0L)
309 return jjStopAtPos(1, 98);
310 break;
311 case 45:
312 if ((active1 & 0x800000000L) != 0L)
313 return jjStopAtPos(1, 99);
314 break;
315 case 47:
316 if ((active0 & 0x100L) != 0L)
317 return jjStopAtPos(1, 8);
318 break;
319 case 60:
320 if ((active1 & 0x100000000000L) != 0L)
321 {
322 jjmatchedKind = 108;
323 jjmatchedPos = 1;
324 }
325 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000000L);
326 case 61:
327 if ((active1 & 0x10000000L) != 0L)
328 return jjStopAtPos(1, 92);
329 else if ((active1 & 0x20000000L) != 0L)
330 return jjStopAtPos(1, 93);
331 else if ((active1 & 0x40000000L) != 0L)
332 return jjStopAtPos(1, 94);
333 else if ((active1 & 0x80000000L) != 0L)
334 return jjStopAtPos(1, 95);
335 else if ((active1 & 0x800000000000L) != 0L)
336 return jjStopAtPos(1, 111);
337 else if ((active1 & 0x1000000000000L) != 0L)
338 return jjStopAtPos(1, 112);
339 else if ((active1 & 0x2000000000000L) != 0L)
340 return jjStopAtPos(1, 113);
341 else if ((active1 & 0x4000000000000L) != 0L)
342 return jjStopAtPos(1, 114);
343 else if ((active1 & 0x8000000000000L) != 0L)
344 return jjStopAtPos(1, 115);
345 else if ((active1 & 0x10000000000000L) != 0L)
346 return jjStopAtPos(1, 116);
347 else if ((active1 & 0x20000000000000L) != 0L)
348 return jjStopAtPos(1, 117);
349 else if ((active1 & 0x40000000000000L) != 0L)
350 return jjStopAtPos(1, 118);
351 break;
352 case 62:
353 if ((active1 & 0x200000000000L) != 0L)
354 {
355 jjmatchedKind = 109;
356 jjmatchedPos = 1;
357 }
358 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x300400000000000L);
359 case 97:
360 return jjMoveStringLiteralDfa2_0(active0, 0x2400200c0000L, active1, 0L);
361 case 98:
362 return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
363 case 101:
364 return jjMoveStringLiteralDfa2_0(active0, 0x2080001000000L, active1, 0L);
365 case 102:
366 if ((active0 & 0x800000000L) != 0L)
367 return jjStartNfaWithStates_0(1, 35, 28);
368 break;
369 case 104:
370 return jjMoveStringLiteralDfa2_0(active0, 0x704000000100000L, active1, 0x1L);
371 case 105:
372 return jjMoveStringLiteralDfa2_0(active0, 0xc0000000L, active1, 0L);
373 case 108:
374 return jjMoveStringLiteralDfa2_0(active0, 0x108200000L, active1, 0L);
375 case 109:
376 return jjMoveStringLiteralDfa2_0(active0, 0x3000000000L, active1, 0L);
377 case 110:
378 return jjMoveStringLiteralDfa2_0(active0, 0x1c000000000L, active1, 0L);
379 case 111:
380 if ((active0 & 0x2000000L) != 0L)
381 {
382 jjmatchedKind = 25;
383 jjmatchedPos = 1;
384 }
385 return jjMoveStringLiteralDfa2_0(active0, 0xc000020604c08000L, active1, 0L);
386 case 114:
387 return jjMoveStringLiteralDfa2_0(active0, 0x3800c00000010000L, active1, 0L);
388 case 115:
389 return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1, 0L);
390 case 116:
391 return jjMoveStringLiteralDfa2_0(active0, 0x18000000000000L, active1, 0L);
392 case 117:
393 return jjMoveStringLiteralDfa2_0(active0, 0x21100000000000L, active1, 0L);
394 case 119:
395 return jjMoveStringLiteralDfa2_0(active0, 0x40000000000000L, active1, 0L);
396 case 120:
397 return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L);
398 case 121:
399 return jjMoveStringLiteralDfa2_0(active0, 0x80000000020000L, active1, 0L);
400 case 124:
401 if ((active1 & 0x100000000L) != 0L)
402 return jjStopAtPos(1, 96);
403 break;
404 default:
405 break;
406 }
407 return jjStartNfa_0(0, active0, active1);
408 }
409
410 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
411 {
412 if (((active0 &= old0) | (active1 &= old1)) == 0L)
413 return jjStartNfa_0(0, old0, old1);
414 try
415 {
416 curChar = input_stream.readChar();
417 }
418 catch (java.io.IOException e)
419 {
420 jjStopStringLiteralDfa_0(1, active0, active1);
421 return 2;
422 }
423 switch (curChar)
424 {
425 case 61:
426 if ((active1 & 0x80000000000000L) != 0L)
427 return jjStopAtPos(2, 119);
428 else if ((active1 & 0x100000000000000L) != 0L)
429 return jjStopAtPos(2, 120);
430 break;
431 case 62:
432 if ((active1 & 0x400000000000L) != 0L)
433 {
434 jjmatchedKind = 110;
435 jjmatchedPos = 2;
436 }
437 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000000000000L);
438 case 97:
439 return jjMoveStringLiteralDfa3_0(active0, 0x808000000300000L, active1, 0L);
440 case 98:
441 return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L, active1, 0L);
442 case 99:
443 return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0L);
444 case 101:
445 return jjMoveStringLiteralDfa3_0(active0, 0x10000L, active1, 0L);
446 case 102:
447 return jjMoveStringLiteralDfa3_0(active0, 0x1000000L, active1, 0L);
448 case 105:
449 return jjMoveStringLiteralDfa3_0(active0, 0x4140400000000000L, active1, 0x1L);
450 case 108:
451 return jjMoveStringLiteralDfa3_0(active0, 0x8000100020000000L, active1, 0L);
452 case 110:
453 return jjMoveStringLiteralDfa3_0(active0, 0x800200c0c00000L, active1, 0L);
454 case 111:
455 return jjMoveStringLiteralDfa3_0(active0, 0x4800100008000L, active1, 0L);
456 case 112:
457 return jjMoveStringLiteralDfa3_0(active0, 0x20003000000000L, active1, 0L);
458 case 114:
459 if ((active0 & 0x200000000L) != 0L)
460 return jjStartNfaWithStates_0(2, 33, 28);
461 return jjMoveStringLiteralDfa3_0(active0, 0x610000000000000L, active1, 0L);
462 case 115:
463 return jjMoveStringLiteralDfa3_0(active0, 0x4008046000L, active1, 0L);
464 case 116:
465 if ((active0 & 0x8000000000L) != 0L)
466 {
467 jjmatchedKind = 39;
468 jjmatchedPos = 2;
469 }
470 return jjMoveStringLiteralDfa3_0(active0, 0x20504100a0000L, active1, 0L);
471 case 117:
472 return jjMoveStringLiteralDfa3_0(active0, 0x1000000004000000L, active1, 0L);
473 case 119:
474 if ((active0 & 0x80000000000L) != 0L)
475 return jjStartNfaWithStates_0(2, 43, 28);
476 break;
477 case 121:
478 if ((active0 & 0x2000000000000000L) != 0L)
479 return jjStartNfaWithStates_0(2, 61, 28);
480 break;
481 default:
482 break;
483 }
484 return jjStartNfa_0(1, active0, active1);
485 }
486
487 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
488 {
489 if (((active0 &= old0) | (active1 &= old1)) == 0L)
490 return jjStartNfa_0(1, old0, old1);
491 try
492 {
493 curChar = input_stream.readChar();
494 }
495 catch (java.io.IOException e)
496 {
497 jjStopStringLiteralDfa_0(2, active0, active1);
498 return 3;
499 }
500 switch (curChar)
501 {
502 case 61:
503 if ((active1 & 0x200000000000000L) != 0L)
504 return jjStopAtPos(3, 121);
505 break;
506 case 97:
507 return jjMoveStringLiteralDfa4_0(active0, 0x80000001c1010000L, active1, 0L);
508 case 98:
509 return jjMoveStringLiteralDfa4_0(active0, 0x4000000L, active1, 0L);
510 case 99:
511 return jjMoveStringLiteralDfa4_0(active0, 0x80000000080000L, active1, 0L);
512 case 100:
513 if ((active0 & 0x4000000000000000L) != 0L)
514 return jjStartNfaWithStates_0(3, 62, 28);
515 break;
516 case 101:
517 if ((active0 & 0x20000L) != 0L)
518 return jjStartNfaWithStates_0(3, 17, 28);
519 else if ((active0 & 0x40000L) != 0L)
520 return jjStartNfaWithStates_0(3, 18, 28);
521 else if ((active0 & 0x8000000L) != 0L)
522 return jjStartNfaWithStates_0(3, 27, 28);
523 else if ((active0 & 0x1000000000000000L) != 0L)
524 return jjStartNfaWithStates_0(3, 60, 28);
525 return jjMoveStringLiteralDfa4_0(active0, 0x20010010004000L, active1, 0L);
526 case 103:
527 if ((active0 & 0x20000000000L) != 0L)
528 return jjStartNfaWithStates_0(3, 41, 28);
529 break;
530 case 105:
531 return jjMoveStringLiteralDfa4_0(active0, 0x10040000000000L, active1, 0L);
532 case 107:
533 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
534 case 108:
535 if ((active0 & 0x100000000000L) != 0L)
536 return jjStartNfaWithStates_0(3, 44, 28);
537 return jjMoveStringLiteralDfa4_0(active0, 0x1001000008000L, active1, 0x1L);
538 case 110:
539 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000L, active1, 0L);
540 case 111:
541 if ((active0 & 0x400000000L) != 0L)
542 return jjStartNfaWithStates_0(3, 34, 28);
543 return jjMoveStringLiteralDfa4_0(active0, 0x600002000000000L, active1, 0L);
544 case 114:
545 if ((active0 & 0x100000L) != 0L)
546 return jjStartNfaWithStates_0(3, 20, 28);
547 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0L);
548 case 115:
549 if ((active0 & 0x100000000000000L) != 0L)
550 return jjStartNfaWithStates_0(3, 56, 28);
551 return jjMoveStringLiteralDfa4_0(active0, 0x20600000L, active1, 0L);
552 case 116:
553 return jjMoveStringLiteralDfa4_0(active0, 0x48804000802000L, active1, 0L);
554 case 117:
555 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
556 case 118:
557 return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L);
558 default:
559 break;
560 }
561 return jjStartNfa_0(2, active0, active1);
562 }
563
564 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
565 {
566 if (((active0 &= old0) | (active1 &= old1)) == 0L)
567 return jjStartNfa_0(2, old0, old1);
568 try
569 {
570 curChar = input_stream.readChar();
571 }
572 catch (java.io.IOException e)
573 {
574 jjStopStringLiteralDfa_0(3, active0, active1);
575 return 4;
576 }
577 switch (curChar)
578 {
579 case 97:
580 return jjMoveStringLiteralDfa5_0(active0, 0x604000000000L, active1, 0L);
581 case 99:
582 return jjMoveStringLiteralDfa5_0(active0, 0x50000000000000L, active1, 0L);
583 case 101:
584 if ((active0 & 0x20000000L) != 0L)
585 return jjStartNfaWithStates_0(4, 29, 28);
586 else if ((active1 & 0x1L) != 0L)
587 return jjStartNfaWithStates_0(4, 64, 28);
588 return jjMoveStringLiteralDfa5_0(active0, 0x801000008000L, active1, 0L);
589 case 104:
590 if ((active0 & 0x80000L) != 0L)
591 return jjStartNfaWithStates_0(4, 19, 28);
592 return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0L);
593 case 105:
594 return jjMoveStringLiteralDfa5_0(active0, 0x9000000800000L, active1, 0L);
595 case 107:
596 if ((active0 & 0x10000L) != 0L)
597 return jjStartNfaWithStates_0(4, 16, 28);
598 break;
599 case 108:
600 if ((active0 & 0x40000000L) != 0L)
601 {
602 jjmatchedKind = 30;
603 jjmatchedPos = 4;
604 }
605 return jjMoveStringLiteralDfa5_0(active0, 0x84000000L, active1, 0L);
606 case 110:
607 return jjMoveStringLiteralDfa5_0(active0, 0x10000000L, active1, 0L);
608 case 114:
609 if ((active0 & 0x20000000000000L) != 0L)
610 return jjStartNfaWithStates_0(4, 53, 28);
611 return jjMoveStringLiteralDfa5_0(active0, 0x2012000006000L, active1, 0L);
612 case 115:
613 if ((active0 & 0x200000L) != 0L)
614 return jjStartNfaWithStates_0(4, 21, 28);
615 return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L);
616 case 116:
617 if ((active0 & 0x400000L) != 0L)
618 return jjStartNfaWithStates_0(4, 22, 28);
619 else if ((active0 & 0x100000000L) != 0L)
620 return jjStartNfaWithStates_0(4, 32, 28);
621 else if ((active0 & 0x4000000000000L) != 0L)
622 return jjStartNfaWithStates_0(4, 50, 28);
623 return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000000L, active1, 0L);
624 case 117:
625 return jjMoveStringLiteralDfa5_0(active0, 0x1000000L, active1, 0L);
626 case 118:
627 return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L, active1, 0L);
628 case 119:
629 if ((active0 & 0x200000000000000L) != 0L)
630 {
631 jjmatchedKind = 57;
632 jjmatchedPos = 4;
633 }
634 return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0L);
635 default:
636 break;
637 }
638 return jjStartNfa_0(3, active0, active1);
639 }
640
641 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
642 {
643 if (((active0 &= old0) | (active1 &= old1)) == 0L)
644 return jjStartNfa_0(3, old0, old1);
645 try
646 {
647 curChar = input_stream.readChar();
648 }
649 catch (java.io.IOException e)
650 {
651 jjStopStringLiteralDfa_0(4, active0, 0L);
652 return 5;
653 }
654 switch (curChar)
655 {
656 case 97:
657 return jjMoveStringLiteralDfa6_0(active0, 0xa000L);
658 case 99:
659 if ((active0 & 0x1000000000000L) != 0L)
660 return jjStartNfaWithStates_0(5, 48, 28);
661 else if ((active0 & 0x8000000000000L) != 0L)
662 return jjStartNfaWithStates_0(5, 51, 28);
663 return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L);
664 case 100:
665 return jjMoveStringLiteralDfa6_0(active0, 0x10000000L);
666 case 101:
667 if ((active0 & 0x4000000L) != 0L)
668 return jjStartNfaWithStates_0(5, 26, 28);
669 else if ((active0 & 0x40000000000L) != 0L)
670 return jjStartNfaWithStates_0(5, 42, 28);
671 break;
672 case 102:
673 return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L);
674 case 103:
675 return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
676 case 104:
677 if ((active0 & 0x40000000000000L) != 0L)
678 return jjStartNfaWithStates_0(5, 54, 28);
679 break;
680 case 105:
681 return jjMoveStringLiteralDfa6_0(active0, 0x8800000000000000L);
682 case 108:
683 return jjMoveStringLiteralDfa6_0(active0, 0x81000000L);
684 case 109:
685 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L);
686 case 110:
687 if ((active0 & 0x2000000000000L) != 0L)
688 return jjStartNfaWithStates_0(5, 49, 28);
689 return jjMoveStringLiteralDfa6_0(active0, 0x4000800000L);
690 case 114:
691 return jjMoveStringLiteralDfa6_0(active0, 0x80000000000000L);
692 case 115:
693 if ((active0 & 0x400000000000000L) != 0L)
694 return jjStartNfaWithStates_0(5, 58, 28);
695 break;
696 case 116:
697 if ((active0 & 0x4000L) != 0L)
698 return jjStartNfaWithStates_0(5, 14, 28);
699 else if ((active0 & 0x2000000000L) != 0L)
700 return jjStartNfaWithStates_0(5, 37, 28);
701 return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L);
702 default:
703 break;
704 }
705 return jjStartNfa_0(4, active0, 0L);
706 }
707
708 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
709 {
710 if (((active0 &= old0)) == 0L)
711 return jjStartNfa_0(4, old0, 0L);
712 try
713 {
714 curChar = input_stream.readChar();
715 }
716 catch (java.io.IOException e)
717 {
718 jjStopStringLiteralDfa_0(5, active0, 0L);
719 return 6;
720 }
721 switch (curChar)
722 {
723 case 97:
724 return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L);
725 case 99:
726 return jjMoveStringLiteralDfa7_0(active0, 0x4000002000L);
727 case 101:
728 if ((active0 & 0x200000000000L) != 0L)
729 return jjStartNfaWithStates_0(6, 45, 28);
730 else if ((active0 & 0x400000000000L) != 0L)
731 return jjStartNfaWithStates_0(6, 46, 28);
732 return jjMoveStringLiteralDfa7_0(active0, 0x800001000000000L);
733 case 102:
734 return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
735 case 108:
736 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L);
737 case 110:
738 if ((active0 & 0x8000L) != 0L)
739 return jjStartNfaWithStates_0(6, 15, 28);
740 break;
741 case 111:
742 return jjMoveStringLiteralDfa7_0(active0, 0x80000000000000L);
743 case 115:
744 if ((active0 & 0x10000000L) != 0L)
745 return jjStartNfaWithStates_0(6, 28, 28);
746 break;
747 case 116:
748 if ((active0 & 0x1000000L) != 0L)
749 return jjStartNfaWithStates_0(6, 24, 28);
750 return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L);
751 case 117:
752 return jjMoveStringLiteralDfa7_0(active0, 0x800000L);
753 case 121:
754 if ((active0 & 0x80000000L) != 0L)
755 return jjStartNfaWithStates_0(6, 31, 28);
756 break;
757 default:
758 break;
759 }
760 return jjStartNfa_0(5, active0, 0L);
761 }
762
763 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
764 {
765 if (((active0 &= old0)) == 0L)
766 return jjStartNfa_0(5, old0, 0L);
767 try
768 {
769 curChar = input_stream.readChar();
770 }
771 catch (java.io.IOException e)
772 {
773 jjStopStringLiteralDfa_0(6, active0, 0L);
774 return 7;
775 }
776 switch (curChar)
777 {
778 case 99:
779 return jjMoveStringLiteralDfa8_0(active0, 0x10000000000L);
780 case 101:
781 if ((active0 & 0x800000L) != 0L)
782 return jjStartNfaWithStates_0(7, 23, 28);
783 else if ((active0 & 0x8000000000000000L) != 0L)
784 return jjStartNfaWithStates_0(7, 63, 28);
785 return jjMoveStringLiteralDfa8_0(active0, 0x804000000000L);
786 case 110:
787 return jjMoveStringLiteralDfa8_0(active0, 0x880001000000000L);
788 case 112:
789 if ((active0 & 0x10000000000000L) != 0L)
790 return jjStartNfaWithStates_0(7, 52, 28);
791 break;
792 case 116:
793 if ((active0 & 0x2000L) != 0L)
794 return jjStartNfaWithStates_0(7, 13, 28);
795 break;
796 default:
797 break;
798 }
799 return jjStartNfa_0(6, active0, 0L);
800 }
801
802 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
803 {
804 if (((active0 &= old0)) == 0L)
805 return jjStartNfa_0(6, old0, 0L);
806 try
807 {
808 curChar = input_stream.readChar();
809 }
810 catch (java.io.IOException e)
811 {
812 jjStopStringLiteralDfa_0(7, active0, 0L);
813 return 8;
814 }
815 switch (curChar)
816 {
817 case 100:
818 if ((active0 & 0x800000000000L) != 0L)
819 return jjStartNfaWithStates_0(8, 47, 28);
820 break;
821 case 101:
822 if ((active0 & 0x10000000000L) != 0L)
823 return jjStartNfaWithStates_0(8, 40, 28);
824 break;
825 case 105:
826 return jjMoveStringLiteralDfa9_0(active0, 0x80000000000000L);
827 case 111:
828 return jjMoveStringLiteralDfa9_0(active0, 0x4000000000L);
829 case 116:
830 if ((active0 & 0x800000000000000L) != 0L)
831 return jjStartNfaWithStates_0(8, 59, 28);
832 return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
833 default:
834 break;
835 }
836 return jjStartNfa_0(7, active0, 0L);
837 }
838
839 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
840 {
841 if (((active0 &= old0)) == 0L)
842 return jjStartNfa_0(7, old0, 0L);
843 try
844 {
845 curChar = input_stream.readChar();
846 }
847 catch (java.io.IOException e)
848 {
849 jjStopStringLiteralDfa_0(8, active0, 0L);
850 return 9;
851 }
852 switch (curChar)
853 {
854 case 102:
855 if ((active0 & 0x4000000000L) != 0L)
856 return jjStartNfaWithStates_0(9, 38, 28);
857 break;
858 case 115:
859 if ((active0 & 0x1000000000L) != 0L)
860 return jjStartNfaWithStates_0(9, 36, 28);
861 break;
862 case 122:
863 return jjMoveStringLiteralDfa10_0(active0, 0x80000000000000L);
864 default:
865 break;
866 }
867 return jjStartNfa_0(8, active0, 0L);
868 }
869
870 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
871 {
872 if (((active0 &= old0)) == 0L)
873 return jjStartNfa_0(8, old0, 0L);
874 try
875 {
876 curChar = input_stream.readChar();
877 }
878 catch (java.io.IOException e)
879 {
880 jjStopStringLiteralDfa_0(9, active0, 0L);
881 return 10;
882 }
883 switch (curChar)
884 {
885 case 101:
886 return jjMoveStringLiteralDfa11_0(active0, 0x80000000000000L);
887 default:
888 break;
889 }
890 return jjStartNfa_0(9, active0, 0L);
891 }
892
893 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
894 {
895 if (((active0 &= old0)) == 0L)
896 return jjStartNfa_0(9, old0, 0L);
897 try
898 {
899 curChar = input_stream.readChar();
900 }
901 catch (java.io.IOException e)
902 {
903 jjStopStringLiteralDfa_0(10, active0, 0L);
904 return 11;
905 }
906 switch (curChar)
907 {
908 case 100:
909 if ((active0 & 0x80000000000000L) != 0L)
910 return jjStartNfaWithStates_0(11, 55, 28);
911 break;
912 default:
913 break;
914 }
915 return jjStartNfa_0(10, active0, 0L);
916 }
917
918 private final void jjCheckNAdd(int state)
919 {
920 if (jjrounds[state] != jjround)
921 {
922 jjstateSet[jjnewStateCnt++] = state;
923 jjrounds[state] = jjround;
924 }
925 }
926
927 private final void jjAddStates(int start, int end)
928 {
929 do
930 {
931 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
932 } while (start++ != end);
933 }
934
935 private final void jjCheckNAddTwoStates(int state1, int state2)
936 {
937 jjCheckNAdd(state1);
938 jjCheckNAdd(state2);
939 }
940
941 private final void jjCheckNAddStates(int start, int end)
942 {
943 do
944 {
945 jjCheckNAdd(jjnextStates[start]);
946 } while (start++ != end);
947 }
948
949 private static final long[] jjbitVec0 = { 0xfffffffffffffffeL, 0xffffffffffffffffL,
950 0xffffffffffffffffL, 0xffffffffffffffffL };
951 private static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL };
952 private static final long[] jjbitVec3 = { 0x1ff00000fffffffeL, 0xffffffffffffc000L,
953 0xffffffffL, 0x600000000000000L };
954 private static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL };
955 private static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL,
956 0xffffffffffffffffL };
957 private static final long[] jjbitVec6 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL,
958 0x0L };
959 private static final long[] jjbitVec7 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L };
960 private static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };
961
962 private final int jjMoveNfa_0(int startState, int curPos)
963 {
964 int startsAt = 0;
965 jjnewStateCnt = 48;
966 int i = 1;
967 jjstateSet[0] = startState;
968 int kind = 0x7fffffff;
969 for (;;)
970 {
971 if (++jjround == 0x7fffffff)
972 ReInitRounds();
973 if (curChar < 64)
974 {
975 long l = 1L << curChar;
976 MatchLoop: do
977 {
978 switch (jjstateSet[--i])
979 {
980 case 0:
981 if ((0x3ff000000000000L & l) != 0L)
982 jjCheckNAddStates(0, 6);
983 else if (curChar == 36)
984 {
985 if (kind > 73)
986 kind = 73;
987 jjCheckNAdd(28);
988 }
989 else if (curChar == 34)
990 jjCheckNAddStates(7, 9);
991 else if (curChar == 39)
992 jjAddStates(10, 11);
993 else if (curChar == 46)
994 jjCheckNAdd(4);
995 if ((0x3fe000000000000L & l) != 0L)
996 {
997 if (kind > 65)
998 kind = 65;
999 jjCheckNAddTwoStates(1, 2);
1000 }
1001 else if (curChar == 48)
1002 {
1003 if (kind > 65)
1004 kind = 65;
1005 jjCheckNAddStates(12, 14);
1006 }
1007 break;
1008 case 1:
1009 if ((0x3ff000000000000L & l) == 0L)
1010 break;
1011 if (kind > 65)
1012 kind = 65;
1013 jjCheckNAddTwoStates(1, 2);
1014 break;
1015 case 3:
1016 if (curChar == 46)
1017 jjCheckNAdd(4);
1018 break;
1019 case 4:
1020 if ((0x3ff000000000000L & l) == 0L)
1021 break;
1022 if (kind > 69)
1023 kind = 69;
1024 jjCheckNAddStates(15, 17);
1025 break;
1026 case 6:
1027 if ((0x280000000000L & l) != 0L)
1028 jjCheckNAdd(7);
1029 break;
1030 case 7:
1031 if ((0x3ff000000000000L & l) == 0L)
1032 break;
1033 if (kind > 69)
1034 kind = 69;
1035 jjCheckNAddTwoStates(7, 8);
1036 break;
1037 case 9:
1038 if (curChar == 39)
1039 jjAddStates(10, 11);
1040 break;
1041 case 10:
1042 if ((0xfffffffffffffbffL & l) != 0L)
1043 jjCheckNAdd(11);
1044 break;
1045 case 11:
1046 if (curChar == 39 && kind > 71)
1047 kind = 71;
1048 break;
1049 case 13:
1050 if ((0x8400000000L & l) != 0L)
1051 jjCheckNAdd(11);
1052 break;
1053 case 14:
1054 if ((0xff000000000000L & l) != 0L)
1055 jjCheckNAddTwoStates(15, 11);
1056 break;
1057 case 15:
1058 if ((0xff000000000000L & l) != 0L)
1059 jjCheckNAdd(11);
1060 break;
1061 case 16:
1062 if ((0xf000000000000L & l) != 0L)
1063 jjstateSet[jjnewStateCnt++] = 17;
1064 break;
1065 case 17:
1066 if ((0xff000000000000L & l) != 0L)
1067 jjCheckNAdd(15);
1068 break;
1069 case 18:
1070 if (curChar == 34)
1071 jjCheckNAddStates(7, 9);
1072 break;
1073 case 19:
1074 if ((0xfffffffbffffdbffL & l) != 0L)
1075 jjCheckNAddStates(7, 9);
1076 break;
1077 case 21:
1078 if ((0x8400000000L & l) != 0L)
1079 jjCheckNAddStates(7, 9);
1080 break;
1081 case 22:
1082 if (curChar == 34 && kind > 72)
1083 kind = 72;
1084 break;
1085 case 23:
1086 if ((0xff000000000000L & l) != 0L)
1087 jjCheckNAddStates(18, 21);
1088 break;
1089 case 24:
1090 if ((0xff000000000000L & l) != 0L)
1091 jjCheckNAddStates(7, 9);
1092 break;
1093 case 25:
1094 if ((0xf000000000000L & l) != 0L)
1095 jjstateSet[jjnewStateCnt++] = 26;
1096 break;
1097 case 26:
1098 if ((0xff000000000000L & l) != 0L)
1099 jjCheckNAdd(24);
1100 break;
1101 case 27:
1102 if (curChar != 36)
1103 break;
1104 if (kind > 73)
1105 kind = 73;
1106 jjCheckNAdd(28);
1107 break;
1108 case 28:
1109 if ((0x3ff001000000000L & l) == 0L)
1110 break;
1111 if (kind > 73)
1112 kind = 73;
1113 jjCheckNAdd(28);
1114 break;
1115 case 29:
1116 if ((0x3ff000000000000L & l) != 0L)
1117 jjCheckNAddStates(0, 6);
1118 break;
1119 case 30:
1120 if ((0x3ff000000000000L & l) != 0L)
1121 jjCheckNAddTwoStates(30, 31);
1122 break;
1123 case 31:
1124 if (curChar != 46)
1125 break;
1126 if (kind > 69)
1127 kind = 69;
1128 jjCheckNAddStates(22, 24);
1129 break;
1130 case 32:
1131 if ((0x3ff000000000000L & l) == 0L)
1132 break;
1133 if (kind > 69)
1134 kind = 69;
1135 jjCheckNAddStates(22, 24);
1136 break;
1137 case 34:
1138 if ((0x280000000000L & l) != 0L)
1139 jjCheckNAdd(35);
1140 break;
1141 case 35:
1142 if ((0x3ff000000000000L & l) == 0L)
1143 break;
1144 if (kind > 69)
1145 kind = 69;
1146 jjCheckNAddTwoStates(35, 8);
1147 break;
1148 case 36:
1149 if ((0x3ff000000000000L & l) != 0L)
1150 jjCheckNAddTwoStates(36, 37);
1151 break;
1152 case 38:
1153 if ((0x280000000000L & l) != 0L)
1154 jjCheckNAdd(39);
1155 break;
1156 case 39:
1157 if ((0x3ff000000000000L & l) == 0L)
1158 break;
1159 if (kind > 69)
1160 kind = 69;
1161 jjCheckNAddTwoStates(39, 8);
1162 break;
1163 case 40:
1164 if ((0x3ff000000000000L & l) != 0L)
1165 jjCheckNAddStates(25, 27);
1166 break;
1167 case 42:
1168 if ((0x280000000000L & l) != 0L)
1169 jjCheckNAdd(43);
1170 break;
1171 case 43:
1172 if ((0x3ff000000000000L & l) != 0L)
1173 jjCheckNAddTwoStates(43, 8);
1174 break;
1175 case 44:
1176 if (curChar != 48)
1177 break;
1178 if (kind > 65)
1179 kind = 65;
1180 jjCheckNAddStates(12, 14);
1181 break;
1182 case 46:
1183 if ((0x3ff000000000000L & l) == 0L)
1184 break;
1185 if (kind > 65)
1186 kind = 65;
1187 jjCheckNAddTwoStates(46, 2);
1188 break;
1189 case 47:
1190 if ((0xff000000000000L & l) == 0L)
1191 break;
1192 if (kind > 65)
1193 kind = 65;
1194 jjCheckNAddTwoStates(47, 2);
1195 break;
1196 default:
1197 break;
1198 }
1199 } while (i != startsAt);
1200 }
1201 else if (curChar < 128)
1202 {
1203 long l = 1L << (curChar & 077);
1204 MatchLoop: do
1205 {
1206 switch (jjstateSet[--i])
1207 {
1208 case 0:
1209 case 28:
1210 if ((0x7fffffe87fffffeL & l) == 0L)
1211 break;
1212 if (kind > 73)
1213 kind = 73;
1214 jjCheckNAdd(28);
1215 break;
1216 case 2:
1217 if ((0x100000001000L & l) != 0L && kind > 65)
1218 kind = 65;
1219 break;
1220 case 5:
1221 if ((0x2000000020L & l) != 0L)
1222 jjAddStates(28, 29);
1223 break;
1224 case 8:
1225 if ((0x5000000050L & l) != 0L && kind > 69)
1226 kind = 69;
1227 break;
1228 case 10:
1229 if ((0xffffffffefffffffL & l) != 0L)
1230 jjCheckNAdd(11);
1231 break;
1232 case 12:
1233 if (curChar == 92)
1234 jjAddStates(30, 32);
1235 break;
1236 case 13:
1237 if ((0x14404410000000L & l) != 0L)
1238 jjCheckNAdd(11);
1239 break;
1240 case 19:
1241 if ((0xffffffffefffffffL & l) != 0L)
1242 jjCheckNAddStates(7, 9);
1243 break;
1244 case 20:
1245 if (curChar == 92)
1246 jjAddStates(33, 35);
1247 break;
1248 case 21:
1249 if ((0x14404410000000L & l) != 0L)
1250 jjCheckNAddStates(7, 9);
1251 break;
1252 case 33:
1253 if ((0x2000000020L & l) != 0L)
1254 jjAddStates(36, 37);
1255 break;
1256 case 37:
1257 if ((0x2000000020L & l) != 0L)
1258 jjAddStates(38, 39);
1259 break;
1260 case 41:
1261 if ((0x2000000020L & l) != 0L)
1262 jjAddStates(40, 41);
1263 break;
1264 case 45:
1265 if ((0x100000001000000L & l) != 0L)
1266 jjCheckNAdd(46);
1267 break;
1268 case 46:
1269 if ((0x7e0000007eL & l) == 0L)
1270 break;
1271 if (kind > 65)
1272 kind = 65;
1273 jjCheckNAddTwoStates(46, 2);
1274 break;
1275 default:
1276 break;
1277 }
1278 } while (i != startsAt);
1279 }
1280 else
1281 {
1282 int hiByte = curChar >> 8;
1283 int i1 = hiByte >> 6;
1284 long l1 = 1L << (hiByte & 077);
1285 int i2 = (curChar & 0xff) >> 6;
1286 long l2 = 1L << (curChar & 077);
1287 MatchLoop: do
1288 {
1289 switch (jjstateSet[--i])
1290 {
1291 case 0:
1292 case 28:
1293 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1294 break;
1295 if (kind > 73)
1296 kind = 73;
1297 jjCheckNAdd(28);
1298 break;
1299 case 10:
1300 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1301 jjstateSet[jjnewStateCnt++] = 11;
1302 break;
1303 case 19:
1304 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1305 jjAddStates(7, 9);
1306 break;
1307 default:
1308 break;
1309 }
1310 } while (i != startsAt);
1311 }
1312 if (kind != 0x7fffffff)
1313 {
1314 jjmatchedKind = kind;
1315 jjmatchedPos = curPos;
1316 kind = 0x7fffffff;
1317 }
1318 ++curPos;
1319 if ((i = jjnewStateCnt) == (startsAt = 48 - (jjnewStateCnt = startsAt)))
1320 return curPos;
1321 try
1322 {
1323 curChar = input_stream.readChar();
1324 }
1325 catch (java.io.IOException e)
1326 {
1327 return curPos;
1328 }
1329 }
1330 }
1331
1332 private final int jjStopStringLiteralDfa_2(int pos)
1333 {
1334 switch (pos)
1335 {
1336 default:
1337 return -1;
1338 }
1339 }
1340
1341 private final int jjStartNfa_2(int pos)
1342 {
1343 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos), pos + 1);
1344 }
1345
1346 private final int jjMoveStringLiteralDfa0_2()
1347 {
1348 switch (curChar)
1349 {
1350 case 42:
1351 return jjMoveStringLiteralDfa1_2(0x800L);
1352 default:
1353 return jjMoveNfa_2(0, 0);
1354 }
1355 }
1356
1357 private final int jjMoveStringLiteralDfa1_2(long active0)
1358 {
1359 try
1360 {
1361 curChar = input_stream.readChar();
1362 }
1363 catch (java.io.IOException e)
1364 {
1365 jjStopStringLiteralDfa_2(0);
1366 return 1;
1367 }
1368 switch (curChar)
1369 {
1370 case 47:
1371 if ((active0 & 0x800L) != 0L)
1372 return jjStopAtPos(1, 11);
1373 break;
1374 default:
1375 break;
1376 }
1377 return jjStartNfa_2(0);
1378 }
1379
1380 private final int jjMoveNfa_2(int startState, int curPos)
1381 {
1382 int startsAt = 0;
1383 jjnewStateCnt = 3;
1384 int i = 1;
1385 jjstateSet[0] = startState;
1386 int kind = 0x7fffffff;
1387 for (;;)
1388 {
1389 if (++jjround == 0x7fffffff)
1390 ReInitRounds();
1391 if (curChar < 64)
1392 {
1393 long l = 1L << curChar;
1394 MatchLoop: do
1395 {
1396 switch (jjstateSet[--i])
1397 {
1398 case 0:
1399 if ((0x2400L & l) != 0L)
1400 {
1401 if (kind > 10)
1402 kind = 10;
1403 }
1404 if (curChar == 13)
1405 jjstateSet[jjnewStateCnt++] = 1;
1406 break;
1407 case 1:
1408 if (curChar == 10 && kind > 10)
1409 kind = 10;
1410 break;
1411 case 2:
1412 if (curChar == 13)
1413 jjstateSet[jjnewStateCnt++] = 1;
1414 break;
1415 default:
1416 break;
1417 }
1418 } while (i != startsAt);
1419 }
1420 else
1421 {
1422 MatchLoop: do
1423 {
1424 switch (jjstateSet[--i])
1425 {
1426 default:
1427 break;
1428 }
1429 } while (i != startsAt);
1430 }
1431 if (kind != 0x7fffffff)
1432 {
1433 jjmatchedKind = kind;
1434 jjmatchedPos = curPos;
1435 kind = 0x7fffffff;
1436 }
1437 ++curPos;
1438 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1439 return curPos;
1440 try
1441 {
1442 curChar = input_stream.readChar();
1443 }
1444 catch (java.io.IOException e)
1445 {
1446 return curPos;
1447 }
1448 }
1449 }
1450
1451 private final int jjMoveStringLiteralDfa0_1()
1452 {
1453 return jjMoveNfa_1(4, 0);
1454 }
1455
1456 private final int jjMoveNfa_1(int startState, int curPos)
1457 {
1458 int startsAt = 0;
1459 jjnewStateCnt = 4;
1460 int i = 1;
1461 jjstateSet[0] = startState;
1462 int kind = 0x7fffffff;
1463 for (;;)
1464 {
1465 if (++jjround == 0x7fffffff)
1466 ReInitRounds();
1467 if (curChar < 64)
1468 {
1469 long l = 1L << curChar;
1470 MatchLoop: do
1471 {
1472 switch (jjstateSet[--i])
1473 {
1474 case 4:
1475 if ((0xffffffffffffdbffL & l) != 0L)
1476 {
1477 if (kind > 9)
1478 kind = 9;
1479 jjCheckNAddStates(42, 44);
1480 }
1481 else if ((0x2400L & l) != 0L)
1482 {
1483 if (kind > 9)
1484 kind = 9;
1485 }
1486 if (curChar == 13)
1487 jjstateSet[jjnewStateCnt++] = 2;
1488 break;
1489 case 0:
1490 if ((0xffffffffffffdbffL & l) == 0L)
1491 break;
1492 kind = 9;
1493 jjCheckNAddStates(42, 44);
1494 break;
1495 case 1:
1496 if ((0x2400L & l) != 0L && kind > 9)
1497 kind = 9;
1498 break;
1499 case 2:
1500 if (curChar == 10 && kind > 9)
1501 kind = 9;
1502 break;
1503 case 3:
1504 if (curChar == 13)
1505 jjstateSet[jjnewStateCnt++] = 2;
1506 break;
1507 default:
1508 break;
1509 }
1510 } while (i != startsAt);
1511 }
1512 else if (curChar < 128)
1513 {
1514 MatchLoop: do
1515 {
1516 switch (jjstateSet[--i])
1517 {
1518 case 4:
1519 case 0:
1520 kind = 9;
1521 jjCheckNAddStates(42, 44);
1522 break;
1523 default:
1524 break;
1525 }
1526 } while (i != startsAt);
1527 }
1528 else
1529 {
1530 int hiByte = curChar >> 8;
1531 int i1 = hiByte >> 6;
1532 long l1 = 1L << (hiByte & 077);
1533 int i2 = (curChar & 0xff) >> 6;
1534 long l2 = 1L << (curChar & 077);
1535 MatchLoop: do
1536 {
1537 switch (jjstateSet[--i])
1538 {
1539 case 4:
1540 case 0:
1541 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1542 break;
1543 if (kind > 9)
1544 kind = 9;
1545 jjCheckNAddStates(42, 44);
1546 break;
1547 default:
1548 break;
1549 }
1550 } while (i != startsAt);
1551 }
1552 if (kind != 0x7fffffff)
1553 {
1554 jjmatchedKind = kind;
1555 jjmatchedPos = curPos;
1556 kind = 0x7fffffff;
1557 }
1558 ++curPos;
1559 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1560 return curPos;
1561 try
1562 {
1563 curChar = input_stream.readChar();
1564 }
1565 catch (java.io.IOException e)
1566 {
1567 return curPos;
1568 }
1569 }
1570 }
1571
1572 private static final int[] jjnextStates = { 30, 31, 36, 37, 40, 41, 8, 19, 20, 22, 10, 12, 45,
1573 47, 2, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 40, 41, 8, 6, 7, 13, 14, 16, 21, 23, 25, 34,
1574 35, 38, 39, 42, 43, 0, 1, 3, };
1575
1576 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1577 {
1578 switch (hiByte)
1579 {
1580 case 0:
1581 return ((jjbitVec2[i2] & l2) != 0L);
1582 default:
1583 if ((jjbitVec0[i1] & l1) != 0L)
1584 return true;
1585 return false;
1586 }
1587 }
1588
1589 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1590 {
1591 switch (hiByte)
1592 {
1593 case 0:
1594 return ((jjbitVec4[i2] & l2) != 0L);
1595 case 48:
1596 return ((jjbitVec5[i2] & l2) != 0L);
1597 case 49:
1598 return ((jjbitVec6[i2] & l2) != 0L);
1599 case 51:
1600 return ((jjbitVec7[i2] & l2) != 0L);
1601 case 61:
1602 return ((jjbitVec8[i2] & l2) != 0L);
1603 default:
1604 if ((jjbitVec3[i1] & l1) != 0L)
1605 return true;
1606 return false;
1607 }
1608 }
1609
1610 private static final String [] jjstrLiteralImages = { "", null, null, null, null, null, null,
1611 null, null, null, null, null, null, "\141\142\163\164\162\141\143\164",
1612 "\141\163\163\145\162\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153",
1613 "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162",
1614 "\143\154\141\163\163", "\143\157\156\163\164", "\143\157\156\164\151\156\165\145",
1615 "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145",
1616 "\145\154\163\145", "\145\170\164\145\156\144\163", "\146\141\154\163\145",
1617 "\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164",
1618 "\146\157\162", "\147\157\164\157", "\151\146",
1619 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164",
1620 "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1621 "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145",
1622 "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
1623 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144",
1624 "\160\165\142\154\151\143", "\162\145\164\165\162\156", "\163\150\157\162\164",
1625 "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160", "\163\165\160\145\162",
1626 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144",
1627 "\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163",
1628 "\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171",
1629 "\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null,
1630 null, null, null, null, null, null, null, null, null, null, "\50", "\51", "\173",
1631 "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74", "\41", "\176", "\77",
1632 "\72", "\75\75", "\74\75", "\76\75", "\41\75", "\174\174", "\46\46", "\53\53",
1633 "\55\55", "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76",
1634 "\76\76\76", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75",
1635 "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75", };
1636 private static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1, -1, 2, 1, 0, -1, 0, -1,
1637 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1638 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1639 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1640 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1641 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
1642 private static final long[] jjtoToken = { 0xffffffffffffe001L, 0x3fffffffffff3a3L, };
1643 private static final long[] jjtoSkip = { 0xf7eL, 0x0L, };
1644 private static final long[] jjtoSpecial = { 0xf00L, 0x0L, };
1645 private ASCII_UCodeESC_CharStream input_stream;
1646 private final int[] jjrounds = new int[48];
1647 private final int[] jjstateSet = new int[96];
1648 private StringBuffer image;
1649 private int jjimageLen;
1650 private char curChar;
1651
1652 public JavaParserTokenManager(ASCII_UCodeESC_CharStream stream)
1653 {
1654 if (ASCII_UCodeESC_CharStream.staticFlag)
1655 throw new Error (
1656 "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1657 input_stream = stream;
1658 }
1659
1660 private final void ReInitRounds()
1661 {
1662 int i;
1663 jjround = 0x80000001;
1664 for (i = 48; i-- > 0;)
1665 jjrounds[i] = 0x80000000;
1666 }
1667
1668 private final Token jjFillToken()
1669 {
1670 Token t = Token.newToken(jjmatchedKind);
1671 t.kind = jjmatchedKind;
1672 if (jjmatchedPos < 0)
1673 {
1674 t.image = "";
1675 t.beginLine = t.endLine = input_stream.getBeginLine();
1676 t.beginColumn = t.endColumn = input_stream.getBeginColumn();
1677 }
1678 else
1679 {
1680 String im = jjstrLiteralImages[jjmatchedKind];
1681 t.image = (im == null) ? input_stream.getImage() : im;
1682 t.beginLine = input_stream.getBeginLine();
1683 t.beginColumn = input_stream.getBeginColumn();
1684 t.endLine = input_stream.getEndLine();
1685 t.endColumn = input_stream.getEndColumn();
1686 }
1687 return t;
1688 }
1689
1690 private int curLexState = 0;
1691 private int jjnewStateCnt;
1692 private int jjround;
1693 private int jjmatchedPos;
1694 private int jjmatchedKind;
1695
1696 public final Token getNextToken()
1697 {
1698 Token specialToken = null;
1699 Token matchedToken;
1700 int curPos = 0;
1701
1702 EOFLoop: for (;;)
1703 {
1704 try
1705 {
1706 curChar = input_stream.beginToken();
1707 }
1708 catch (java.io.IOException e)
1709 {
1710 jjmatchedKind = 0;
1711 matchedToken = jjFillToken();
1712 matchedToken.specialToken = specialToken;
1713 return matchedToken;
1714 }
1715 image = null;
1716 jjimageLen = 0;
1717
1718 for (;;)
1719 {
1720 switch (curLexState)
1721 {
1722 case 0:
1723 try
1724 {
1725 input_stream.backup(0);
1726 while (curChar <= 32 && (0x104003600L & (1L << curChar)) != 0L)
1727 curChar = input_stream.beginToken();
1728 }
1729 catch (java.io.IOException e1)
1730 {
1731 continue EOFLoop;
1732 }
1733 jjmatchedKind = 0x7fffffff;
1734 jjmatchedPos = 0;
1735 curPos = jjMoveStringLiteralDfa0_0();
1736 break;
1737 case 1:
1738 jjmatchedKind = 9;
1739 jjmatchedPos = -1;
1740 curPos = 0;
1741 curPos = jjMoveStringLiteralDfa0_1();
1742 if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 12))
1743 {
1744 jjmatchedKind = 12;
1745 jjmatchedPos = 0;
1746 }
1747 break;
1748 case 2:
1749 jjmatchedKind = 0x7fffffff;
1750 jjmatchedPos = 0;
1751 curPos = jjMoveStringLiteralDfa0_2();
1752 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1753 {
1754 jjmatchedKind = 12;
1755 }
1756 break;
1757 }
1758 if (jjmatchedKind != 0x7fffffff)
1759 {
1760 if (jjmatchedPos + 1 < curPos)
1761 input_stream.backup(curPos - jjmatchedPos - 1);
1762 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1763 {
1764 matchedToken = jjFillToken();
1765 matchedToken.specialToken = specialToken;
1766 if (jjnewLexState[jjmatchedKind] != -1)
1767 curLexState = jjnewLexState[jjmatchedKind];
1768 return matchedToken;
1769 }
1770 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1771 {
1772 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1773 {
1774 matchedToken = jjFillToken();
1775 if (specialToken == null)
1776 specialToken = matchedToken;
1777 else
1778 {
1779 matchedToken.specialToken = specialToken;
1780 specialToken = (specialToken.next = matchedToken);
1781 }
1782 SkipLexicalActions();
1783 }
1784 else
1785 SkipLexicalActions();
1786 if (jjnewLexState[jjmatchedKind] != -1)
1787 curLexState = jjnewLexState[jjmatchedKind];
1788 continue EOFLoop;
1789 }
1790 MoreLexicalActions();
1791 if (jjnewLexState[jjmatchedKind] != -1)
1792 curLexState = jjnewLexState[jjmatchedKind];
1793 curPos = 0;
1794 jjmatchedKind = 0x7fffffff;
1795 try
1796 {
1797 curChar = input_stream.readChar();
1798 continue;
1799 }
1800 catch (java.io.IOException e1)
1801 {
1802 }
1803 }
1804 int error_line = input_stream.getEndLine();
1805 int error_column = input_stream.getEndColumn();
1806 String error_after = null;
1807 boolean EOFSeen = false;
1808 try
1809 {
1810 input_stream.readChar();
1811 input_stream.backup(1);
1812 }
1813 catch (java.io.IOException e1)
1814 {
1815 EOFSeen = true;
1816 error_after = curPos <= 1 ? "" : input_stream.getImage();
1817 if (curChar == '\n' || curChar == '\r')
1818 {
1819 error_line++;
1820 error_column = 0;
1821 }
1822 else
1823 error_column++;
1824 }
1825 if (!EOFSeen)
1826 {
1827 input_stream.backup(1);
1828 error_after = curPos <= 1 ? "" : input_stream.getImage();
1829 }
1830 throw new TokenMgrError(EOFSeen, error_line, error_column, error_after, curChar,
1831 TokenMgrError.LEXICAL_ERROR);
1832 }
1833 }
1834 }
1835
1836 private final void SkipLexicalActions()
1837 {
1838 switch (jjmatchedKind)
1839 {
1840 case 8:
1841 if (image == null)
1842 image = new StringBuffer (new String (input_stream.getSuffix(jjimageLen
1843 + jjmatchedPos + 1)));
1844 else
1845 image.append(input_stream.getSuffix(jjimageLen + jjmatchedPos + 1));
1846 break;
1847 case 10:
1848 if (image == null)
1849 image = new StringBuffer (new String (input_stream.getSuffix(jjimageLen
1850 + jjmatchedPos + 1)));
1851 else
1852 image.append(input_stream.getSuffix(jjimageLen + jjmatchedPos + 1));
1853 break;
1854 case 11:
1855 if (image == null)
1856 image = new StringBuffer (new String (input_stream.getSuffix(jjimageLen
1857 + jjmatchedPos + 1)));
1858 else
1859 image.append(input_stream.getSuffix(jjimageLen + jjmatchedPos + 1));
1860 break;
1861 default:
1862 break;
1863 }
1864 }
1865
1866 private final void MoreLexicalActions()
1867 {
1868 jjimageLen += jjmatchedPos + 1;
1869 switch (jjmatchedKind)
1870 {
1871 case 7:
1872 if (image == null)
1873 image = new StringBuffer (new String (input_stream.getSuffix(jjimageLen)));
1874 else
1875 image.append(input_stream.getSuffix(jjimageLen));
1876 jjimageLen = 0;
1877 break;
1878 default:
1879 break;
1880 }
1881 }
1882
1883}
1884 |
Popular Tags |
Java API By Example, From Geeks To Geeks.