1
2 package net.sourceforge.pmd.ast;
3 import java.util.*;
4 import net.sourceforge.pmd.PMD;
5
6 /** Token Manager. */
7 public class JavaParserTokenManager implements JavaParserConstants
8 {
9 protected List<Comment> comments = new ArrayList<Comment>();
10
11 private Map<Integer, String> excludeMap = new HashMap<Integer, String>();
12 private String excludeMarker = PMD.EXCLUDE_MARKER;
13
14 public void setExcludeMarker(String marker) {
15 this.excludeMarker = marker;
16 }
17 public Map<Integer, String> getExcludeMap() {
18 return excludeMap;
19 }
20
21 /** Debug output. */
22 public java.io.PrintStream debugStream = System.out;
23 /** Set debug output. */
24 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
25 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
26 {
27 switch (pos)
28 {
29 case 0:
30 if ((active1 & 0x80000000080000L) != 0L)
31 return 4;
32 if ((active0 & 0x7ffffffffffff000L) != 0L)
33 {
34 jjmatchedKind = 72;
35 return 28;
36 }
37 if ((active0 & 0x100L) != 0L || (active1 & 0x804000000000L) != 0L)
38 return 45;
39 return -1;
40 case 1:
41 if ((active0 & 0x201800000L) != 0L)
42 return 28;
43 if ((active0 & 0x7ffffffdfe7ff000L) != 0L)
44 {
45 if (jjmatchedPos != 1)
46 {
47 jjmatchedKind = 72;
48 jjmatchedPos = 1;
49 }
50 return 28;
51 }
52 if ((active0 & 0x100L) != 0L)
53 return 50;
54 return -1;
55 case 2:
56 if ((active0 & 0x400026080000000L) != 0L)
57 return 28;
58 if ((active0 & 0x7bfffd9d7f7ff000L) != 0L)
59 {
60 if (jjmatchedPos != 2)
61 {
62 jjmatchedKind = 72;
63 jjmatchedPos = 2;
64 }
65 return 28;
66 }
67 return -1;
68 case 3:
69 if ((active0 & 0x71dff95c7d7a7000L) != 0L)
70 {
71 jjmatchedKind = 72;
72 jjmatchedPos = 3;
73 return 28;
74 }
75 if ((active0 & 0xa20048102058000L) != 0L)
76 return 28;
77 return -1;
78 case 4:
79 if ((active0 & 0x20c50000781a4000L) != 0L)
80 return 28;
81 if ((active0 & 0x511af95c05603000L) != 0L)
82 {
83 if (jjmatchedPos != 4)
84 {
85 jjmatchedKind = 72;
86 jjmatchedPos = 4;
87 }
88 return 28;
89 }
90 return -1;
91 case 5:
92 if ((active0 & 0x8ac10801000000L) != 0L)
93 return 28;
94 if ((active0 & 0x5110385424603000L) != 0L)
95 {
96 jjmatchedKind = 72;
97 jjmatchedPos = 5;
98 return 28;
99 }
100 return -1;
101 case 6:
102 if ((active0 & 0x5110205400201000L) != 0L)
103 {
104 jjmatchedKind = 72;
105 jjmatchedPos = 6;
106 return 28;
107 }
108 if ((active0 & 0x180024402000L) != 0L)
109 return 28;
110 return -1;
111 case 7:
112 if ((active0 & 0x5000000000201000L) != 0L)
113 return 28;
114 if ((active0 & 0x110205400000000L) != 0L)
115 {
116 jjmatchedKind = 72;
117 jjmatchedPos = 7;
118 return 28;
119 }
120 return -1;
121 case 8:
122 if ((active0 & 0x100204000000000L) != 0L)
123 return 28;
124 if ((active0 & 0x10001400000000L) != 0L)
125 {
126 jjmatchedKind = 72;
127 jjmatchedPos = 8;
128 return 28;
129 }
130 return -1;
131 case 9:
132 if ((active0 & 0x1400000000L) != 0L)
133 return 28;
134 if ((active0 & 0x10000000000000L) != 0L)
135 {
136 jjmatchedKind = 72;
137 jjmatchedPos = 9;
138 return 28;
139 }
140 return -1;
141 case 10:
142 if ((active0 & 0x10000000000000L) != 0L)
143 {
144 jjmatchedKind = 72;
145 jjmatchedPos = 10;
146 return 28;
147 }
148 return -1;
149 default :
150 return -1;
151 }
152 }
153 private final int jjStartNfa_0(int pos, long active0, long active1)
154 {
155 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
156 }
157 private int jjStopAtPos(int pos, int kind)
158 {
159 jjmatchedKind = kind;
160 jjmatchedPos = pos;
161 return pos + 1;
162 }
163 private int jjMoveStringLiteralDfa0_0()
164 {
165 switch(curChar)
166 {
167 case 9:
168 return jjStopAtPos(0, 2);
169 case 10:
170 return jjStopAtPos(0, 3);
171 case 12:
172 return jjStopAtPos(0, 5);
173 case 13:
174 return jjStopAtPos(0, 4);
175 case 26:
176 return jjStopAtPos(0, 123);
177 case 32:
178 return jjStopAtPos(0, 1);
179 case 33:
180 jjmatchedKind = 87;
181 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L);
182 case 37:
183 jjmatchedKind = 106;
184 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
185 case 38:
186 jjmatchedKind = 103;
187 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000100000000L);
188 case 40:
189 return jjStopAtPos(0, 75);
190 case 41:
191 return jjStopAtPos(0, 76);
192 case 42:
193 jjmatchedKind = 101;
194 return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L);
195 case 43:
196 jjmatchedKind = 99;
197 return jjMoveStringLiteralDfa1_0(0x0L, 0x100200000000L);
198 case 44:
199 return jjStopAtPos(0, 82);
200 case 45:
201 jjmatchedKind = 100;
202 return jjMoveStringLiteralDfa1_0(0x0L, 0x200400000000L);
203 case 46:
204 jjmatchedKind = 83;
205 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L);
206 case 47:
207 jjmatchedKind = 102;
208 return jjMoveStringLiteralDfa1_0(0x100L, 0x800000000000L);
209 case 58:
210 return jjStopAtPos(0, 90);
211 case 59:
212 return jjStopAtPos(0, 81);
213 case 60:
214 jjmatchedKind = 86;
215 return jjMoveStringLiteralDfa1_0(0x0L, 0x10080010000000L);
216 case 61:
217 jjmatchedKind = 85;
218 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L);
219 case 62:
220 jjmatchedKind = 122;
221 return jjMoveStringLiteralDfa1_0(0x0L, 0x360000020000000L);
222 case 63:
223 return jjStopAtPos(0, 89);
224 case 64:
225 return jjStopAtPos(0, 84);
226 case 91:
227 return jjStopAtPos(0, 79);
228 case 93:
229 return jjStopAtPos(0, 80);
230 case 94:
231 jjmatchedKind = 105;
232 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L);
233 case 97:
234 return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
235 case 98:
236 return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);
237 case 99:
238 return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);
239 case 100:
240 return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
241 case 101:
242 return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);
243 case 102:
244 return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);
245 case 103:
246 return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
247 case 105:
248 return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);
249 case 108:
250 return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
251 case 110:
252 return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);
253 case 112:
254 return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);
255 case 114:
256 return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);
257 case 115:
258 return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);
259 case 116:
260 return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);
261 case 118:
262 return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);
263 case 119:
264 return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
265 case 123:
266 return jjStopAtPos(0, 77);
267 case 124:
268 jjmatchedKind = 104;
269 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000080000000L);
270 case 125:
271 return jjStopAtPos(0, 78);
272 case 126:
273 jjmatchedKind = 88;
274 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000000L);
275 default :
276 return jjMoveNfa_0(0, 0);
277 }
278 }
279 private int jjMoveStringLiteralDfa1_0(long active0, long active1)
280 {
281 try { curChar = input_stream.readChar(); }
282 catch(java.io.IOException e) {
283 jjStopStringLiteralDfa_0(0, active0, active1);
284 return 1;
285 }
286 switch(curChar)
287 {
288 case 38:
289 if ((active1 & 0x100000000L) != 0L)
290 return jjStopAtPos(1, 96);
291 break;
292 case 42:
293 if ((active0 & 0x100L) != 0L)
294 return jjStartNfaWithStates_0(1, 8, 50);
295 break;
296 case 43:
297 if ((active1 & 0x200000000L) != 0L)
298 return jjStopAtPos(1, 97);
299 break;
300 case 45:
301 if ((active1 & 0x400000000L) != 0L)
302 return jjStopAtPos(1, 98);
303 break;
304 case 46:
305 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000000L);
306 case 60:
307 if ((active1 & 0x80000000000L) != 0L)
308 {
309 jjmatchedKind = 107;
310 jjmatchedPos = 1;
311 }
312 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10000000000000L);
313 case 61:
314 if ((active1 & 0x8000000L) != 0L)
315 return jjStopAtPos(1, 91);
316 else if ((active1 & 0x10000000L) != 0L)
317 return jjStopAtPos(1, 92);
318 else if ((active1 & 0x20000000L) != 0L)
319 return jjStopAtPos(1, 93);
320 else if ((active1 & 0x40000000L) != 0L)
321 return jjStopAtPos(1, 94);
322 else if ((active1 & 0x100000000000L) != 0L)
323 return jjStopAtPos(1, 108);
324 else if ((active1 & 0x200000000000L) != 0L)
325 return jjStopAtPos(1, 109);
326 else if ((active1 & 0x400000000000L) != 0L)
327 return jjStopAtPos(1, 110);
328 else if ((active1 & 0x800000000000L) != 0L)
329 return jjStopAtPos(1, 111);
330 else if ((active1 & 0x1000000000000L) != 0L)
331 return jjStopAtPos(1, 112);
332 else if ((active1 & 0x2000000000000L) != 0L)
333 return jjStopAtPos(1, 113);
334 else if ((active1 & 0x4000000000000L) != 0L)
335 return jjStopAtPos(1, 114);
336 else if ((active1 & 0x8000000000000L) != 0L)
337 return jjStopAtPos(1, 115);
338 break;
339 case 62:
340 if ((active1 & 0x200000000000000L) != 0L)
341 {
342 jjmatchedKind = 121;
343 jjmatchedPos = 1;
344 }
345 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x160000000000000L);
346 case 91:
347 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1000000000000000L);
348 case 97:
349 return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L, active1, 0L);
350 case 98:
351 return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L);
352 case 101:
353 return jjMoveStringLiteralDfa2_0(active0, 0x820000400000L, active1, 0L);
354 case 102:
355 if ((active0 & 0x200000000L) != 0L)
356 return jjStartNfaWithStates_0(1, 33, 28);
357 break;
358 case 104:
359 return jjMoveStringLiteralDfa2_0(active0, 0x20e1000000040000L, active1, 0L);
360 case 105:
361 return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0L);
362 case 108:
363 return jjMoveStringLiteralDfa2_0(active0, 0x42080000L, active1, 0L);
364 case 109:
365 return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0L);
366 case 110:
367 return jjMoveStringLiteralDfa2_0(active0, 0x7000000000L, active1, 0L);
368 case 111:
369 if ((active0 & 0x800000L) != 0L)
370 {
371 jjmatchedKind = 23;
372 jjmatchedPos = 1;
373 }
374 return jjMoveStringLiteralDfa2_0(active0, 0x1800008181302000L, active1, 0L);
375 case 114:
376 return jjMoveStringLiteralDfa2_0(active0, 0x700300000004000L, active1, 0L);
377 case 116:
378 return jjMoveStringLiteralDfa2_0(active0, 0x4002000000000000L, active1, 0L);
379 case 117:
380 return jjMoveStringLiteralDfa2_0(active0, 0x4440000000000L, active1, 0L);
381 case 119:
382 return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0L);
383 case 120:
384 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
385 case 121:
386 return jjMoveStringLiteralDfa2_0(active0, 0x10000000008000L, active1, 0L);
387 case 124:
388 if ((active1 & 0x80000000L) != 0L)
389 return jjStopAtPos(1, 95);
390 break;
391 default :
392 break;
393 }
394 return jjStartNfa_0(0, active0, active1);
395 }
396 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
397 {
398 if (((active0 &= old0) | (active1 &= old1)) == 0L)
399 return jjStartNfa_0(0, old0, old1);
400 try { curChar = input_stream.readChar(); }
401 catch(java.io.IOException e) {
402 jjStopStringLiteralDfa_0(1, active0, active1);
403 return 2;
404 }
405 switch(curChar)
406 {
407 case 46:
408 if ((active1 & 0x80000000000000L) != 0L)
409 return jjStopAtPos(2, 119);
410 break;
411 case 61:
412 if ((active1 & 0x10000000000000L) != 0L)
413 return jjStopAtPos(2, 116);
414 else if ((active1 & 0x20000000000000L) != 0L)
415 return jjStopAtPos(2, 117);
416 break;
417 case 62:
418 if ((active1 & 0x100000000000000L) != 0L)
419 {
420 jjmatchedKind = 120;
421 jjmatchedPos = 2;
422 }
423 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40000000000000L);
424 case 93:
425 if ((active1 & 0x1000000000000000L) != 0L)
426 return jjStopAtPos(2, 124);
427 break;
428 case 97:
429 return jjMoveStringLiteralDfa3_0(active0, 0x1020000000c0000L, active1, 0L);
430 case 98:
431 return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L);
432 case 99:
433 return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0L);
434 case 101:
435 return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0L);
436 case 102:
437 return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L);
438 case 105:
439 return jjMoveStringLiteralDfa3_0(active0, 0x2828100000000000L, active1, 0L);
440 case 108:
441 return jjMoveStringLiteralDfa3_0(active0, 0x1000040008000000L, active1, 0L);
442 case 110:
443 return jjMoveStringLiteralDfa3_0(active0, 0x10008030300000L, active1, 0L);
444 case 111:
445 return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000L, active1, 0L);
446 case 112:
447 return jjMoveStringLiteralDfa3_0(active0, 0x4000c00000000L, active1, 0L);
448 case 114:
449 if ((active0 & 0x80000000L) != 0L)
450 return jjStartNfaWithStates_0(2, 31, 28);
451 return jjMoveStringLiteralDfa3_0(active0, 0x40c0000000000000L, active1, 0L);
452 case 115:
453 return jjMoveStringLiteralDfa3_0(active0, 0x1002011000L, active1, 0L);
454 case 116:
455 if ((active0 & 0x2000000000L) != 0L)
456 {
457 jjmatchedKind = 37;
458 jjmatchedPos = 2;
459 }
460 return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L, active1, 0L);
461 case 117:
462 return jjMoveStringLiteralDfa3_0(active0, 0x200000001000000L, active1, 0L);
463 case 119:
464 if ((active0 & 0x20000000000L) != 0L)
465 return jjStartNfaWithStates_0(2, 41, 28);
466 break;
467 case 121:
468 if ((active0 & 0x400000000000000L) != 0L)
469 return jjStartNfaWithStates_0(2, 58, 28);
470 break;
471 default :
472 break;
473 }
474 return jjStartNfa_0(1, active0, active1);
475 }
476 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
477 {
478 if (((active0 &= old0) | (active1 &= old1)) == 0L)
479 return jjStartNfa_0(1, old0, old1);
480 try { curChar = input_stream.readChar(); }
481 catch(java.io.IOException e) {
482 jjStopStringLiteralDfa_0(2, active0, active1);
483 return 3;
484 }
485 switch(curChar)
486 {
487 case 61:
488 if ((active1 & 0x40000000000000L) != 0L)
489 return jjStopAtPos(3, 118);
490 break;
491 case 97:
492 return jjMoveStringLiteralDfa4_0(active0, 0x1000000070404000L, active1, 0L);
493 case 98:
494 return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0L);
495 case 99:
496 return jjMoveStringLiteralDfa4_0(active0, 0x10000000020000L, active1, 0L);
497 case 100:
498 if ((active0 & 0x800000000000000L) != 0L)
499 return jjStartNfaWithStates_0(3, 59, 28);
500 break;
501 case 101:
502 if ((active0 & 0x8000L) != 0L)
503 return jjStartNfaWithStates_0(3, 15, 28);
504 else if ((active0 & 0x10000L) != 0L)
505 return jjStartNfaWithStates_0(3, 16, 28);
506 else if ((active0 & 0x2000000L) != 0L)
507 return jjStartNfaWithStates_0(3, 25, 28);
508 else if ((active0 & 0x200000000000000L) != 0L)
509 return jjStartNfaWithStates_0(3, 57, 28);
510 return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L, active1, 0L);
511 case 103:
512 if ((active0 & 0x8000000000L) != 0L)
513 return jjStartNfaWithStates_0(3, 39, 28);
514 break;
515 case 105:
516 return jjMoveStringLiteralDfa4_0(active0, 0x4000010000000000L, active1, 0L);
517 case 107:
518 return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0L);
519 case 108:
520 if ((active0 & 0x40000000000L) != 0L)
521 return jjStartNfaWithStates_0(3, 42, 28);
522 return jjMoveStringLiteralDfa4_0(active0, 0x2000400400002000L, active1, 0L);
523 case 110:
524 return jjMoveStringLiteralDfa4_0(active0, 0x100000000000000L, active1, 0L);
525 case 111:
526 if ((active0 & 0x100000000L) != 0L)
527 return jjStartNfaWithStates_0(3, 32, 28);
528 return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0L);
529 case 114:
530 if ((active0 & 0x40000L) != 0L)
531 return jjStartNfaWithStates_0(3, 18, 28);
532 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
533 case 115:
534 if ((active0 & 0x20000000000000L) != 0L)
535 return jjStartNfaWithStates_0(3, 53, 28);
536 return jjMoveStringLiteralDfa4_0(active0, 0x8180000L, active1, 0L);
537 case 116:
538 return jjMoveStringLiteralDfa4_0(active0, 0xa201000201000L, active1, 0L);
539 case 117:
540 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L);
541 case 118:
542 return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
543 default :
544 break;
545 }
546 return jjStartNfa_0(2, active0, active1);
547 }
548 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
549 {
550 if (((active0 &= old0) | (active1 &= old1)) == 0L)
551 return jjStartNfa_0(2, old0, old1);
552 try { curChar = input_stream.readChar(); }
553 catch(java.io.IOException e) {
554 jjStopStringLiteralDfa_0(3, active0, 0L);
555 return 4;
556 }
557 switch(curChar)
558 {
559 case 97:
560 return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L);
561 case 99:
562 return jjMoveStringLiteralDfa5_0(active0, 0x4008000000000000L);
563 case 101:
564 if ((active0 & 0x8000000L) != 0L)
565 return jjStartNfaWithStates_0(4, 27, 28);
566 else if ((active0 & 0x2000000000000000L) != 0L)
567 return jjStartNfaWithStates_0(4, 61, 28);
568 return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);
569 case 104:
570 if ((active0 & 0x20000L) != 0L)
571 return jjStartNfaWithStates_0(4, 17, 28);
572 return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
573 case 105:
574 return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000L);
575 case 107:
576 if ((active0 & 0x4000L) != 0L)
577 return jjStartNfaWithStates_0(4, 14, 28);
578 break;
579 case 108:
580 if ((active0 & 0x10000000L) != 0L)
581 {
582 jjmatchedKind = 28;
583 jjmatchedPos = 4;
584 }
585 return jjMoveStringLiteralDfa5_0(active0, 0x21000000L);
586 case 110:
587 return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
588 case 114:
589 if ((active0 & 0x4000000000000L) != 0L)
590 return jjStartNfaWithStates_0(4, 50, 28);
591 return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);
592 case 115:
593 if ((active0 & 0x80000L) != 0L)
594 return jjStartNfaWithStates_0(4, 19, 28);
595 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);
596 case 116:
597 if ((active0 & 0x100000L) != 0L)
598 return jjStartNfaWithStates_0(4, 20, 28);
599 else if ((active0 & 0x40000000L) != 0L)
600 return jjStartNfaWithStates_0(4, 30, 28);
601 else if ((active0 & 0x1000000000000L) != 0L)
602 return jjStartNfaWithStates_0(4, 48, 28);
603 return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L);
604 case 117:
605 return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
606 case 118:
607 return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
608 case 119:
609 if ((active0 & 0x40000000000000L) != 0L)
610 {
611 jjmatchedKind = 54;
612 jjmatchedPos = 4;
613 }
614 return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
615 default :
616 break;
617 }
618 return jjStartNfa_0(3, active0, 0L);
619 }
620 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
621 {
622 if (((active0 &= old0)) == 0L)
623 return jjStartNfa_0(3, old0, 0L);
624 try { curChar = input_stream.readChar(); }
625 catch(java.io.IOException e) {
626 jjStopStringLiteralDfa_0(4, active0, 0L);
627 return 5;
628 }
629 switch(curChar)
630 {
631 case 97:
632 return jjMoveStringLiteralDfa6_0(active0, 0x3000L);
633 case 99:
634 if ((active0 & 0x400000000000L) != 0L)
635 return jjStartNfaWithStates_0(5, 46, 28);
636 else if ((active0 & 0x2000000000000L) != 0L)
637 return jjStartNfaWithStates_0(5, 49, 28);
638 return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
639 case 100:
640 return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
641 case 101:
642 if ((active0 & 0x1000000L) != 0L)
643 return jjStartNfaWithStates_0(5, 24, 28);
644 else if ((active0 & 0x10000000000L) != 0L)
645 return jjStartNfaWithStates_0(5, 40, 28);
646 break;
647 case 102:
648 return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L);
649 case 103:
650 return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);
651 case 104:
652 if ((active0 & 0x8000000000000L) != 0L)
653 return jjStartNfaWithStates_0(5, 51, 28);
654 break;
655 case 105:
656 return jjMoveStringLiteralDfa6_0(active0, 0x1100000000000000L);
657 case 108:
658 return jjMoveStringLiteralDfa6_0(active0, 0x20400000L);
659 case 109:
660 return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
661 case 110:
662 if ((active0 & 0x800000000000L) != 0L)
663 return jjStartNfaWithStates_0(5, 47, 28);
664 return jjMoveStringLiteralDfa6_0(active0, 0x1000200000L);
665 case 114:
666 return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
667 case 115:
668 if ((active0 & 0x80000000000000L) != 0L)
669 return jjStartNfaWithStates_0(5, 55, 28);
670 break;
671 case 116:
672 if ((active0 & 0x800000000L) != 0L)
673 return jjStartNfaWithStates_0(5, 35, 28);
674 return jjMoveStringLiteralDfa6_0(active0, 0x4000100000000000L);
675 default :
676 break;
677 }
678 return jjStartNfa_0(4, active0, 0L);
679 }
680 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
681 {
682 if (((active0 &= old0)) == 0L)
683 return jjStartNfa_0(4, old0, 0L);
684 try { curChar = input_stream.readChar(); }
685 catch(java.io.IOException e) {
686 jjStopStringLiteralDfa_0(5, active0, 0L);
687 return 6;
688 }
689 switch(curChar)
690 {
691 case 97:
692 return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L);
693 case 99:
694 return jjMoveStringLiteralDfa7_0(active0, 0x1000001000L);
695 case 101:
696 if ((active0 & 0x80000000000L) != 0L)
697 return jjStartNfaWithStates_0(6, 43, 28);
698 else if ((active0 & 0x100000000000L) != 0L)
699 return jjStartNfaWithStates_0(6, 44, 28);
700 return jjMoveStringLiteralDfa7_0(active0, 0x100000400000000L);
701 case 102:
702 return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L);
703 case 108:
704 return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L);
705 case 110:
706 if ((active0 & 0x2000L) != 0L)
707 return jjStartNfaWithStates_0(6, 13, 28);
708 break;
709 case 111:
710 return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
711 case 115:
712 if ((active0 & 0x4000000L) != 0L)
713 return jjStartNfaWithStates_0(6, 26, 28);
714 break;
715 case 116:
716 if ((active0 & 0x400000L) != 0L)
717 return jjStartNfaWithStates_0(6, 22, 28);
718 return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);
719 case 117:
720 return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
721 case 121:
722 if ((active0 & 0x20000000L) != 0L)
723 return jjStartNfaWithStates_0(6, 29, 28);
724 break;
725 default :
726 break;
727 }
728 return jjStartNfa_0(5, active0, 0L);
729 }
730 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
731 {
732 if (((active0 &= old0)) == 0L)
733 return jjStartNfa_0(5, old0, 0L);
734 try { curChar = input_stream.readChar(); }
735 catch(java.io.IOException e) {
736 jjStopStringLiteralDfa_0(6, active0, 0L);
737 return 7;
738 }
739 switch(curChar)
740 {
741 case 99:
742 return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L);
743 case 101:
744 if ((active0 & 0x200000L) != 0L)
745 return jjStartNfaWithStates_0(7, 21, 28);
746 else if ((active0 & 0x1000000000000000L) != 0L)
747 return jjStartNfaWithStates_0(7, 60, 28);
748 return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L);
749 case 110:
750 return jjMoveStringLiteralDfa8_0(active0, 0x110000400000000L);
751 case 112:
752 if ((active0 & 0x4000000000000000L) != 0L)
753 return jjStartNfaWithStates_0(7, 62, 28);
754 break;
755 case 116:
756 if ((active0 & 0x1000L) != 0L)
757 return jjStartNfaWithStates_0(7, 12, 28);
758 break;
759 default :
760 break;
761 }
762 return jjStartNfa_0(6, active0, 0L);
763 }
764 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
765 {
766 if (((active0 &= old0)) == 0L)
767 return jjStartNfa_0(6, old0, 0L);
768 try { curChar = input_stream.readChar(); }
769 catch(java.io.IOException e) {
770 jjStopStringLiteralDfa_0(7, active0, 0L);
771 return 8;
772 }
773 switch(curChar)
774 {
775 case 100:
776 if ((active0 & 0x200000000000L) != 0L)
777 return jjStartNfaWithStates_0(8, 45, 28);
778 break;
779 case 101:
780 if ((active0 & 0x4000000000L) != 0L)
781 return jjStartNfaWithStates_0(8, 38, 28);
782 break;
783 case 105:
784 return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L);
785 case 111:
786 return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
787 case 116:
788 if ((active0 & 0x100000000000000L) != 0L)
789 return jjStartNfaWithStates_0(8, 56, 28);
790 return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
791 default :
792 break;
793 }
794 return jjStartNfa_0(7, active0, 0L);
795 }
796 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
797 {
798 if (((active0 &= old0)) == 0L)
799 return jjStartNfa_0(7, old0, 0L);
800 try { curChar = input_stream.readChar(); }
801 catch(java.io.IOException e) {
802 jjStopStringLiteralDfa_0(8, active0, 0L);
803 return 9;
804 }
805 switch(curChar)
806 {
807 case 102:
808 if ((active0 & 0x1000000000L) != 0L)
809 return jjStartNfaWithStates_0(9, 36, 28);
810 break;
811 case 115:
812 if ((active0 & 0x400000000L) != 0L)
813 return jjStartNfaWithStates_0(9, 34, 28);
814 break;
815 case 122:
816 return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L);
817 default :
818 break;
819 }
820 return jjStartNfa_0(8, active0, 0L);
821 }
822 private int jjMoveStringLiteralDfa10_0(long old0, long active0)
823 {
824 if (((active0 &= old0)) == 0L)
825 return jjStartNfa_0(8, old0, 0L);
826 try { curChar = input_stream.readChar(); }
827 catch(java.io.IOException e) {
828 jjStopStringLiteralDfa_0(9, active0, 0L);
829 return 10;
830 }
831 switch(curChar)
832 {
833 case 101:
834 return jjMoveStringLiteralDfa11_0(active0, 0x10000000000000L);
835 default :
836 break;
837 }
838 return jjStartNfa_0(9, active0, 0L);
839 }
840 private int jjMoveStringLiteralDfa11_0(long old0, long active0)
841 {
842 if (((active0 &= old0)) == 0L)
843 return jjStartNfa_0(9, old0, 0L);
844 try { curChar = input_stream.readChar(); }
845 catch(java.io.IOException e) {
846 jjStopStringLiteralDfa_0(10, active0, 0L);
847 return 11;
848 }
849 switch(curChar)
850 {
851 case 100:
852 if ((active0 & 0x10000000000000L) != 0L)
853 return jjStartNfaWithStates_0(11, 52, 28);
854 break;
855 default :
856 break;
857 }
858 return jjStartNfa_0(10, active0, 0L);
859 }
860 private int jjStartNfaWithStates_0(int pos, int kind, int state)
861 {
862 jjmatchedKind = kind;
863 jjmatchedPos = pos;
864 try { curChar = input_stream.readChar(); }
865 catch(java.io.IOException e) { return pos + 1; }
866 return jjMoveNfa_0(state, pos + 1);
867 }
868 static final long[] jjbitVec0 = {
869 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
870 };
871 static final long[] jjbitVec2 = {
872 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
873 };
874 static final long[] jjbitVec3 = {
875 0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL
876 };
877 static final long[] jjbitVec4 = {
878 0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
879 };
880 static final long[] jjbitVec5 = {
881 0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
882 };
883 static final long[] jjbitVec6 = {
884 0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
885 };
886 static final long[] jjbitVec7 = {
887 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
888 };
889 static final long[] jjbitVec8 = {
890 0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
891 };
892 static final long[] jjbitVec9 = {
893 0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
894 };
895 static final long[] jjbitVec10 = {
896 0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
897 };
898 static final long[] jjbitVec11 = {
899 0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L
900 };
901 static final long[] jjbitVec12 = {
902 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
903 };
904 static final long[] jjbitVec13 = {
905 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
906 };
907 static final long[] jjbitVec14 = {
908 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
909 };
910 static final long[] jjbitVec15 = {
911 0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
912 };
913 static final long[] jjbitVec16 = {
914 0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL
915 };
916 static final long[] jjbitVec17 = {
917 0x1L, 0x7fffffffeffL, 0xf00L, 0x0L
918 };
919 static final long[] jjbitVec18 = {
920 0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
921 };
922 static final long[] jjbitVec19 = {
923 0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
924 };
925 static final long[] jjbitVec20 = {
926 0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
927 };
928 static final long[] jjbitVec21 = {
929 0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
930 };
931 static final long[] jjbitVec22 = {
932 0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
933 };
934 static final long[] jjbitVec23 = {
935 0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L
936 };
937 static final long[] jjbitVec24 = {
938 0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
939 };
940 static final long[] jjbitVec25 = {
941 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
942 };
943 static final long[] jjbitVec26 = {
944 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
945 };
946 static final long[] jjbitVec27 = {
947 0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L
948 };
949 static final long[] jjbitVec28 = {
950 0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
951 };
952 static final long[] jjbitVec29 = {
953 0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL
954 };
955 static final long[] jjbitVec30 = {
956 0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
957 };
958 static final long[] jjbitVec31 = {
959 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
960 };
961 static final long[] jjbitVec32 = {
962 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
963 };
964 static final long[] jjbitVec33 = {
965 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
966 };
967 static final long[] jjbitVec34 = {
968 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
969 };
970 static final long[] jjbitVec35 = {
971 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
972 };
973 static final long[] jjbitVec36 = {
974 0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
975 };
976 static final long[] jjbitVec37 = {
977 0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
978 };
979 static final long[] jjbitVec38 = {
980 0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
981 };
982 static final long[] jjbitVec39 = {
983 0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
984 };
985 static final long[] jjbitVec40 = {
986 0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL
987 };
988 static final long[] jjbitVec41 = {
989 0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
990 };
991 static final long[] jjbitVec42 = {
992 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
993 };
994 static final long[] jjbitVec43 = {
995 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
996 };
997 static final long[] jjbitVec44 = {
998 0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
999 };
1000 static final long[] jjbitVec45 = {
1001 0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
1002 };
1003 static final long[] jjbitVec46 = {
1004 0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL
1005 };
1006 static final long[] jjbitVec47 = {
1007 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
1008 };
1009 static final long[] jjbitVec48 = {
1010 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
1011 };
1012 static final long[] jjbitVec49 = {
1013 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
1014 };
1015 static final long[] jjbitVec50 = {
1016 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
1017 };
1018 static final long[] jjbitVec51 = {
1019 0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL
1020 };
1021 static final long[] jjbitVec52 = {
1022 0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L
1023 };
1024 static final long[] jjbitVec53 = {
1025 0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
1026 };
1027 static final long[] jjbitVec54 = {
1028 0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
1029 };
1030 static final long[] jjbitVec55 = {
1031 0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL
1032 };
1033 static final long[] jjbitVec56 = {
1034 0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
1035 };
1036 static final long[] jjbitVec57 = {
1037 0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L
1038 };
1039 static final long[] jjbitVec58 = {
1040 0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
1041 };
1042 static final long[] jjbitVec59 = {
1043 0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1044 };
1045 static final long[] jjbitVec60 = {
1046 0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
1047 };
1048 static final long[] jjbitVec61 = {
1049 0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
1050 };
1051 private int jjMoveNfa_0(int startState, int curPos)
1052 {
1053 int startsAt = 0;
1054 jjnewStateCnt = 68;
1055 int i = 1;
1056 jjstateSet[0] = startState;
1057 int kind = 0x7fffffff;
1058 for (;;)
1059 {
1060 if (++jjround == 0x7fffffff)
1061 ReInitRounds();
1062 if (curChar < 64)
1063 {
1064 long l = 1L << curChar;
1065 do
1066 {
1067 switch(jjstateSet[--i])
1068 {
1069 case 45:
1070 if (curChar == 42)
1071 jjstateSet[jjnewStateCnt++] = 50;
1072 else if (curChar == 47)
1073 {
1074 if (kind > 6)
1075 kind = 6;
1076 jjCheckNAddStates(0, 2);
1077 }
1078 break;
1079 case 0:
1080 if ((0x3ff000000000000L & l) != 0L)
1081 jjCheckNAddStates(3, 9);
1082 else if (curChar == 47)
1083 jjAddStates(10, 11);
1084 else if (curChar == 36)
1085 {
1086 if (kind > 72)
1087 kind = 72;
1088 jjCheckNAdd(28);
1089 }
1090 else if (curChar == 34)
1091 jjCheckNAddStates(12, 14);
1092 else if (curChar == 39)
1093 jjAddStates(15, 16);
1094 else if (curChar == 46)
1095 jjCheckNAdd(4);
1096 if ((0x3fe000000000000L & l) != 0L)
1097 {
1098 if (kind > 63)
1099 kind = 63;
1100 jjCheckNAddTwoStates(1, 2);
1101 }
1102 else if (curChar == 48)
1103 {
1104 if (kind > 63)
1105 kind = 63;
1106 jjCheckNAddStates(17, 21);
1107 }
1108 break;
1109 case 1:
1110 if ((0x3ff000000000000L & l) == 0L)
1111 break;
1112 if (kind > 63)
1113 kind = 63;
1114 jjCheckNAddTwoStates(1, 2);
1115 break;
1116 case 3:
1117 if (curChar == 46)
1118 jjCheckNAdd(4);
1119 break;
1120 case 4:
1121 if ((0x3ff000000000000L & l) == 0L)
1122 break;
1123 if (kind > 67)
1124 kind = 67;
1125 jjCheckNAddStates(22, 24);
1126 break;
1127 case 6:
1128 if ((0x280000000000L & l) != 0L)
1129 jjCheckNAdd(7);
1130 break;
1131 case 7:
1132 if ((0x3ff000000000000L & l) == 0L)
1133 break;
1134 if (kind > 67)
1135 kind = 67;
1136 jjCheckNAddTwoStates(7, 8);
1137 break;
1138 case 9:
1139 if (curChar == 39)
1140 jjAddStates(15, 16);
1141 break;
1142 case 10:
1143 if ((0xffffff7fffffdbffL & l) != 0L)
1144 jjCheckNAdd(11);
1145 break;
1146 case 11:
1147 if (curChar == 39 && kind > 70)
1148 kind = 70;
1149 break;
1150 case 13:
1151 if ((0x8400000000L & l) != 0L)
1152 jjCheckNAdd(11);
1153 break;
1154 case 14:
1155 if ((0xff000000000000L & l) != 0L)
1156 jjCheckNAddTwoStates(15, 11);
1157 break;
1158 case 15:
1159 if ((0xff000000000000L & l) != 0L)
1160 jjCheckNAdd(11);
1161 break;
1162 case 16:
1163 if ((0xf000000000000L & l) != 0L)
1164 jjstateSet[jjnewStateCnt++] = 17;
1165 break;
1166 case 17:
1167 if ((0xff000000000000L & l) != 0L)
1168 jjCheckNAdd(15);
1169 break;
1170 case 18:
1171 if (curChar == 34)
1172 jjCheckNAddStates(12, 14);
1173 break;
1174 case 19:
1175 if ((0xfffffffbffffdbffL & l) != 0L)
1176 jjCheckNAddStates(12, 14);
1177 break;
1178 case 21:
1179 if ((0x8400000000L & l) != 0L)
1180 jjCheckNAddStates(12, 14);
1181 break;
1182 case 22:
1183 if (curChar == 34 && kind > 71)
1184 kind = 71;
1185 break;
1186 case 23:
1187 if ((0xff000000000000L & l) != 0L)
1188 jjCheckNAddStates(25, 28);
1189 break;
1190 case 24:
1191 if ((0xff000000000000L & l) != 0L)
1192 jjCheckNAddStates(12, 14);
1193 break;
1194 case 25:
1195 if ((0xf000000000000L & l) != 0L)
1196 jjstateSet[jjnewStateCnt++] = 26;
1197 break;
1198 case 26:
1199 if ((0xff000000000000L & l) != 0L)
1200 jjCheckNAdd(24);
1201 break;
1202 case 27:
1203 if (curChar != 36)
1204 break;
1205 if (kind > 72)
1206 kind = 72;
1207 jjCheckNAdd(28);
1208 break;
1209 case 28:
1210 if ((0x3ff00100fffc1ffL & l) == 0L)
1211 break;
1212 if (kind > 72)
1213 kind = 72;
1214 jjCheckNAdd(28);
1215 break;
1216 case 29:
1217 if ((0x3ff000000000000L & l) != 0L)
1218 jjCheckNAddStates(3, 9);
1219 break;
1220 case 30:
1221 if ((0x3ff000000000000L & l) != 0L)
1222 jjCheckNAddTwoStates(30, 31);
1223 break;
1224 case 31:
1225 if (curChar != 46)
1226 break;
1227 if (kind > 67)
1228 kind = 67;
1229 jjCheckNAddStates(29, 31);
1230 break;
1231 case 32:
1232 if ((0x3ff000000000000L & l) == 0L)
1233 break;
1234 if (kind > 67)
1235 kind = 67;
1236 jjCheckNAddStates(29, 31);
1237 break;
1238 case 34:
1239 if ((0x280000000000L & l) != 0L)
1240 jjCheckNAdd(35);
1241 break;
1242 case 35:
1243 if ((0x3ff000000000000L & l) == 0L)
1244 break;
1245 if (kind > 67)
1246 kind = 67;
1247 jjCheckNAddTwoStates(35, 8);
1248 break;
1249 case 36:
1250 if ((0x3ff000000000000L & l) != 0L)
1251 jjCheckNAddTwoStates(36, 37);
1252 break;
1253 case 38:
1254 if ((0x280000000000L & l) != 0L)
1255 jjCheckNAdd(39);
1256 break;
1257 case 39:
1258 if ((0x3ff000000000000L & l) == 0L)
1259 break;
1260 if (kind > 67)
1261 kind = 67;
1262 jjCheckNAddTwoStates(39, 8);
1263 break;
1264 case 40:
1265 if ((0x3ff000000000000L & l) != 0L)
1266 jjCheckNAddStates(32, 34);
1267 break;
1268 case 42:
1269 if ((0x280000000000L & l) != 0L)
1270 jjCheckNAdd(43);
1271 break;
1272 case 43:
1273 if ((0x3ff000000000000L & l) != 0L)
1274 jjCheckNAddTwoStates(43, 8);
1275 break;
1276 case 44:
1277 if (curChar == 47)
1278 jjAddStates(10, 11);
1279 break;
1280 case 46:
1281 if ((0xffffffffffffdbffL & l) == 0L)
1282 break;
1283 if (kind > 6)
1284 kind = 6;
1285 jjCheckNAddStates(0, 2);
1286 break;
1287 case 47:
1288 if ((0x2400L & l) != 0L && kind > 6)
1289 kind = 6;
1290 break;
1291 case 48:
1292 if (curChar == 10 && kind > 6)
1293 kind = 6;
1294 break;
1295 case 49:
1296 if (curChar == 13)
1297 jjstateSet[jjnewStateCnt++] = 48;
1298 break;
1299 case 50:
1300 if (curChar == 42)
1301 jjstateSet[jjnewStateCnt++] = 51;
1302 break;
1303 case 51:
1304 if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1305 kind = 7;
1306 break;
1307 case 52:
1308 if (curChar == 42)
1309 jjstateSet[jjnewStateCnt++] = 50;
1310 break;
1311 case 53:
1312 if (curChar != 48)
1313 break;
1314 if (kind > 63)
1315 kind = 63;
1316 jjCheckNAddStates(17, 21);
1317 break;
1318 case 55:
1319 if ((0x3ff000000000000L & l) == 0L)
1320 break;
1321 if (kind > 63)
1322 kind = 63;
1323 jjCheckNAddTwoStates(55, 2);
1324 break;
1325 case 56:
1326 if ((0xff000000000000L & l) == 0L)
1327 break;
1328 if (kind > 63)
1329 kind = 63;
1330 jjCheckNAddTwoStates(56, 2);
1331 break;
1332 case 58:
1333 if ((0x3ff000000000000L & l) != 0L)
1334 jjCheckNAddStates(35, 37);
1335 break;
1336 case 59:
1337 if (curChar == 46)
1338 jjCheckNAdd(60);
1339 break;
1340 case 61:
1341 if ((0x280000000000L & l) != 0L)
1342 jjCheckNAdd(62);
1343 break;
1344 case 62:
1345 if ((0x3ff000000000000L & l) == 0L)
1346 break;
1347 if (kind > 68)
1348 kind = 68;
1349 jjCheckNAddTwoStates(62, 63);
1350 break;
1351 case 65:
1352 if ((0x3ff000000000000L & l) != 0L)
1353 jjAddStates(38, 39);
1354 break;
1355 case 66:
1356 if (curChar == 46)
1357 jjCheckNAdd(67);
1358 break;
1359 case 67:
1360 if ((0x3ff000000000000L & l) != 0L)
1361 jjCheckNAddTwoStates(67, 60);
1362 break;
1363 default : break;
1364 }
1365 } while(i != startsAt);
1366 }
1367 else if (curChar < 128)
1368 {
1369 long l = 1L << (curChar & 077);
1370 do
1371 {
1372 switch(jjstateSet[--i])
1373 {
1374 case 0:
1375 if ((0x7fffffe87fffffeL & l) == 0L)
1376 break;
1377 if (kind > 72)
1378 kind = 72;
1379 jjCheckNAdd(28);
1380 break;
1381 case 2:
1382 if ((0x100000001000L & l) != 0L && kind > 63)
1383 kind = 63;
1384 break;
1385 case 5:
1386 if ((0x2000000020L & l) != 0L)
1387 jjAddStates(40, 41);
1388 break;
1389 case 8:
1390 if ((0x5000000050L & l) != 0L && kind > 67)
1391 kind = 67;
1392 break;
1393 case 10:
1394 if ((0xffffffffefffffffL & l) != 0L)
1395 jjCheckNAdd(11);
1396 break;
1397 case 12:
1398 if (curChar == 92)
1399 jjAddStates(42, 44);
1400 break;
1401 case 13:
1402 if ((0x14404410000000L & l) != 0L)
1403 jjCheckNAdd(11);
1404 break;
1405 case 19:
1406 if ((0xffffffffefffffffL & l) != 0L)
1407 jjCheckNAddStates(12, 14);
1408 break;
1409 case 20:
1410 if (curChar == 92)
1411 jjAddStates(45, 47);
1412 break;
1413 case 21:
1414 if ((0x14404410000000L & l) != 0L)
1415 jjCheckNAddStates(12, 14);
1416 break;
1417 case 28:
1418 if ((0x87fffffe87fffffeL & l) == 0L)
1419 break;
1420 if (kind > 72)
1421 kind = 72;
1422 jjCheckNAdd(28);
1423 break;
1424 case 33:
1425 if ((0x2000000020L & l) != 0L)
1426 jjAddStates(48, 49);
1427 break;
1428 case 37:
1429 if ((0x2000000020L & l) != 0L)
1430 jjAddStates(50, 51);
1431 break;
1432 case 41:
1433 if ((0x2000000020L & l) != 0L)
1434 jjAddStates(52, 53);
1435 break;
1436 case 46:
1437 if (kind > 6)
1438 kind = 6;
1439 jjAddStates(0, 2);
1440 break;
1441 case 51:
1442 if (kind > 7)
1443 kind = 7;
1444 break;
1445 case 54:
1446 if ((0x100000001000000L & l) != 0L)
1447 jjCheckNAdd(55);
1448 break;
1449 case 55:
1450 if ((0x7e0000007eL & l) == 0L)
1451 break;
1452 if (kind > 63)
1453 kind = 63;
1454 jjCheckNAddTwoStates(55, 2);
1455 break;
1456 case 57:
1457 if ((0x100000001000000L & l) != 0L)
1458 jjCheckNAdd(58);
1459 break;
1460 case 58:
1461 if ((0x7e0000007eL & l) != 0L)
1462 jjCheckNAddStates(35, 37);
1463 break;
1464 case 60:
1465 if ((0x1000000010000L & l) != 0L)
1466 jjAddStates(54, 55);
1467 break;
1468 case 63:
1469 if ((0x5000000050L & l) != 0L && kind > 68)
1470 kind = 68;
1471 break;
1472 case 64:
1473 if ((0x100000001000000L & l) != 0L)
1474 jjCheckNAddTwoStates(65, 66);
1475 break;
1476 case 65:
1477 if ((0x7e0000007eL & l) != 0L)
1478 jjCheckNAddTwoStates(65, 66);
1479 break;
1480 case 67:
1481 if ((0x7e0000007eL & l) != 0L)
1482 jjCheckNAddTwoStates(67, 60);
1483 break;
1484 default : break;
1485 }
1486 } while(i != startsAt);
1487 }
1488 else
1489 {
1490 int hiByte = (int)(curChar >> 8);
1491 int i1 = hiByte >> 6;
1492 long l1 = 1L << (hiByte & 077);
1493 int i2 = (curChar & 0xff) >> 6;
1494 long l2 = 1L << (curChar & 077);
1495 do
1496 {
1497 switch(jjstateSet[--i])
1498 {
1499 case 0:
1500 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1501 break;
1502 if (kind > 72)
1503 kind = 72;
1504 jjCheckNAdd(28);
1505 break;
1506 case 10:
1507 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1508 jjstateSet[jjnewStateCnt++] = 11;
1509 break;
1510 case 19:
1511 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1512 jjAddStates(12, 14);
1513 break;
1514 case 28:
1515 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1516 break;
1517 if (kind > 72)
1518 kind = 72;
1519 jjCheckNAdd(28);
1520 break;
1521 case 46:
1522 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1523 break;
1524 if (kind > 6)
1525 kind = 6;
1526 jjAddStates(0, 2);
1527 break;
1528 case 51:
1529 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
1530 kind = 7;
1531 break;
1532 default : break;
1533 }
1534 } while(i != startsAt);
1535 }
1536 if (kind != 0x7fffffff)
1537 {
1538 jjmatchedKind = kind;
1539 jjmatchedPos = curPos;
1540 kind = 0x7fffffff;
1541 }
1542 ++curPos;
1543 if ((i = jjnewStateCnt) == (startsAt = 68 - (jjnewStateCnt = startsAt)))
1544 return curPos;
1545 try { curChar = input_stream.readChar(); }
1546 catch(java.io.IOException e) { return curPos; }
1547 }
1548 }
1549 private int jjMoveStringLiteralDfa0_2()
1550 {
1551 switch(curChar)
1552 {
1553 case 42:
1554 return jjMoveStringLiteralDfa1_2(0x400L);
1555 default :
1556 return 1;
1557 }
1558 }
1559 private int jjMoveStringLiteralDfa1_2(long active0)
1560 {
1561 try { curChar = input_stream.readChar(); }
1562 catch(java.io.IOException e) {
1563 return 1;
1564 }
1565 switch(curChar)
1566 {
1567 case 47:
1568 if ((active0 & 0x400L) != 0L)
1569 return jjStopAtPos(1, 10);
1570 break;
1571 default :
1572 return 2;
1573 }
1574 return 2;
1575 }
1576 private int jjMoveStringLiteralDfa0_1()
1577 {
1578 switch(curChar)
1579 {
1580 case 42:
1581 return jjMoveStringLiteralDfa1_1(0x200L);
1582 default :
1583 return 1;
1584 }
1585 }
1586 private int jjMoveStringLiteralDfa1_1(long active0)
1587 {
1588 try { curChar = input_stream.readChar(); }
1589 catch(java.io.IOException e) {
1590 return 1;
1591 }
1592 switch(curChar)
1593 {
1594 case 47:
1595 if ((active0 & 0x200L) != 0L)
1596 return jjStopAtPos(1, 9);
1597 break;
1598 default :
1599 return 2;
1600 }
1601 return 2;
1602 }
1603 static final int[] jjnextStates = {
1604 46, 47, 49, 30, 31, 36, 37, 40, 41, 8, 45, 52, 19, 20, 22, 10,
1605 12, 54, 56, 2, 57, 64, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8,
1606 40, 41, 8, 58, 59, 60, 65, 66, 6, 7, 13, 14, 16, 21, 23, 25,
1607 34, 35, 38, 39, 42, 43, 61, 62,
1608 };
1609 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1610 {
1611 switch(hiByte)
1612 {
1613 case 0:
1614 return ((jjbitVec2[i2] & l2) != 0L);
1615 default :
1616 if ((jjbitVec0[i1] & l1) != 0L)
1617 return true;
1618 return false;
1619 }
1620 }
1621 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1622 {
1623 switch(hiByte)
1624 {
1625 case 0:
1626 return ((jjbitVec4[i2] & l2) != 0L);
1627 case 2:
1628 return ((jjbitVec5[i2] & l2) != 0L);
1629 case 3:
1630 return ((jjbitVec6[i2] & l2) != 0L);
1631 case 4:
1632 return ((jjbitVec7[i2] & l2) != 0L);
1633 case 5:
1634 return ((jjbitVec8[i2] & l2) != 0L);
1635 case 6:
1636 return ((jjbitVec9[i2] & l2) != 0L);
1637 case 7:
1638 return ((jjbitVec10[i2] & l2) != 0L);
1639 case 9:
1640 return ((jjbitVec11[i2] & l2) != 0L);
1641 case 10:
1642 return ((jjbitVec12[i2] & l2) != 0L);
1643 case 11:
1644 return ((jjbitVec13[i2] & l2) != 0L);
1645 case 12:
1646 return ((jjbitVec14[i2] & l2) != 0L);
1647 case 13:
1648 return ((jjbitVec15[i2] & l2) != 0L);
1649 case 14:
1650 return ((jjbitVec16[i2] & l2) != 0L);
1651 case 15:
1652 return ((jjbitVec17[i2] & l2) != 0L);
1653 case 16:
1654 return ((jjbitVec18[i2] & l2) != 0L);
1655 case 17:
1656 return ((jjbitVec19[i2] & l2) != 0L);
1657 case 18:
1658 return ((jjbitVec20[i2] & l2) != 0L);
1659 case 19:
1660 return ((jjbitVec21[i2] & l2) != 0L);
1661 case 20:
1662 return ((jjbitVec0[i2] & l2) != 0L);
1663 case 22:
1664 return ((jjbitVec22[i2] & l2) != 0L);
1665 case 23:
1666 return ((jjbitVec23[i2] & l2) != 0L);
1667 case 24:
1668 return ((jjbitVec24[i2] & l2) != 0L);
1669 case 30:
1670 return ((jjbitVec25[i2] & l2) != 0L);
1671 case 31:
1672 return ((jjbitVec26[i2] & l2) != 0L);
1673 case 32:
1674 return ((jjbitVec27[i2] & l2) != 0L);
1675 case 33:
1676 return ((jjbitVec28[i2] & l2) != 0L);
1677 case 48:
1678 return ((jjbitVec29[i2] & l2) != 0L);
1679 case 49:
1680 return ((jjbitVec30[i2] & l2) != 0L);
1681 case 77:
1682 return ((jjbitVec31[i2] & l2) != 0L);
1683 case 159:
1684 return ((jjbitVec32[i2] & l2) != 0L);
1685 case 164:
1686 return ((jjbitVec33[i2] & l2) != 0L);
1687 case 215:
1688 return ((jjbitVec34[i2] & l2) != 0L);
1689 case 250:
1690 return ((jjbitVec35[i2] & l2) != 0L);
1691 case 251:
1692 return ((jjbitVec36[i2] & l2) != 0L);
1693 case 253:
1694 return ((jjbitVec37[i2] & l2) != 0L);
1695 case 254:
1696 return ((jjbitVec38[i2] & l2) != 0L);
1697 case 255:
1698 return ((jjbitVec39[i2] & l2) != 0L);
1699 default :
1700 if ((jjbitVec3[i1] & l1) != 0L)
1701 return true;
1702 return false;
1703 }
1704 }
1705 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1706 {
1707 switch(hiByte)
1708 {
1709 case 0:
1710 return ((jjbitVec40[i2] & l2) != 0L);
1711 case 2:
1712 return ((jjbitVec5[i2] & l2) != 0L);
1713 case 3:
1714 return ((jjbitVec41[i2] & l2) != 0L);
1715 case 4:
1716 return ((jjbitVec42[i2] & l2) != 0L);
1717 case 5:
1718 return ((jjbitVec43[i2] & l2) != 0L);
1719 case 6:
1720 return ((jjbitVec44[i2] & l2) != 0L);
1721 case 7:
1722 return ((jjbitVec45[i2] & l2) != 0L);
1723 case 9:
1724 return ((jjbitVec46[i2] & l2) != 0L);
1725 case 10:
1726 return ((jjbitVec47[i2] & l2) != 0L);
1727 case 11:
1728 return ((jjbitVec48[i2] & l2) != 0L);
1729 case 12:
1730 return ((jjbitVec49[i2] & l2) != 0L);
1731 case 13:
1732 return ((jjbitVec50[i2] & l2) != 0L);
1733 case 14:
1734 return ((jjbitVec51[i2] & l2) != 0L);
1735 case 15:
1736 return ((jjbitVec52[i2] & l2) != 0L);
1737 case 16:
1738 return ((jjbitVec53[i2] & l2) != 0L);
1739 case 17:
1740 return ((jjbitVec19[i2] & l2) != 0L);
1741 case 18:
1742 return ((jjbitVec20[i2] & l2) != 0L);
1743 case 19:
1744 return ((jjbitVec54[i2] & l2) != 0L);
1745 case 20:
1746 return ((jjbitVec0[i2] & l2) != 0L);
1747 case 22:
1748 return ((jjbitVec22[i2] & l2) != 0L);
1749 case 23:
1750 return ((jjbitVec55[i2] & l2) != 0L);
1751 case 24:
1752 return ((jjbitVec56[i2] & l2) != 0L);
1753 case 30:
1754 return ((jjbitVec25[i2] & l2) != 0L);
1755 case 31:
1756 return ((jjbitVec26[i2] & l2) != 0L);
1757 case 32:
1758 return ((jjbitVec57[i2] & l2) != 0L);
1759 case 33:
1760 return ((jjbitVec28[i2] & l2) != 0L);
1761 case 48:
1762 return ((jjbitVec58[i2] & l2) != 0L);
1763 case 49:
1764 return ((jjbitVec30[i2] & l2) != 0L);
1765 case 77:
1766 return ((jjbitVec31[i2] & l2) != 0L);
1767 case 159:
1768 return ((jjbitVec32[i2] & l2) != 0L);
1769 case 164:
1770 return ((jjbitVec33[i2] & l2) != 0L);
1771 case 215:
1772 return ((jjbitVec34[i2] & l2) != 0L);
1773 case 250:
1774 return ((jjbitVec35[i2] & l2) != 0L);
1775 case 251:
1776 return ((jjbitVec59[i2] & l2) != 0L);
1777 case 253:
1778 return ((jjbitVec37[i2] & l2) != 0L);
1779 case 254:
1780 return ((jjbitVec60[i2] & l2) != 0L);
1781 case 255:
1782 return ((jjbitVec61[i2] & l2) != 0L);
1783 default :
1784 if ((jjbitVec3[i1] & l1) != 0L)
1785 return true;
1786 return false;
1787 }
1788 }
1789
1790 /** Token literal values. */
1791 public static final String[] jjstrLiteralImages = {
1792 "", null, null, null, null, null, null, null, null, null, null, null,
1793 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145",
1794 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163",
1795 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
1796 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
1797 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154",
1798 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146",
1799 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146",
1800 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1801 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
1802 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
1803 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162",
1804 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
1805 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164",
1806 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
1807 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null, null, null, null, null, null,
1808 null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73",
1809 "\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75",
1810 "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52",
1811 "\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75",
1812 "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75",
1813 "\76\76\76\75", "\56\56\56", "\76\76\76", "\76\76", "\76", "\32", "\176\133\135", };
1814
1815 /** Lexer state names. */
1816 public static final String[] lexStateNames = {
1817 "DEFAULT",
1818 "IN_FORMAL_COMMENT",
1819 "IN_MULTI_LINE_COMMENT",
1820 };
1821
1822 /** Lex State array. */
1823 public static final int[] jjnewLexState = {
1824 -1, -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1825 -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,
1826 -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,
1827 -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,
1828 -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,
1829 };
1830 static final long[] jjtoToken = {
1831 0xfffffffffffff001L, 0x1ffffffffffff9d8L,
1832 };
1833 static final long[] jjtoSkip = {
1834 0x67eL, 0x0L,
1835 };
1836 static final long[] jjtoSpecial = {
1837 0x67eL, 0x0L,
1838 };
1839 static final long[] jjtoMore = {
1840 0x980L, 0x0L,
1841 };
1842 protected CharStream input_stream;
1843 private final int[] jjrounds = new int[68];
1844 private final int[] jjstateSet = new int[136];
1845 private final StringBuilder jjimage = new StringBuilder();
1846 private StringBuilder image = jjimage;
1847 private int jjimageLen;
1848 private int lengthOfMatch;
1849 protected char curChar;
1850 /** Constructor. */
1851 public JavaParserTokenManager(CharStream stream){
1852 input_stream = stream;
1853 }
1854
1855 /** Constructor. */
1856 public JavaParserTokenManager(CharStream stream, int lexState){
1857 this(stream);
1858 SwitchTo(lexState);
1859 }
1860
1861 /** Reinitialise parser. */
1862 public void ReInit(CharStream stream)
1863 {
1864 jjmatchedPos = jjnewStateCnt = 0;
1865 curLexState = defaultLexState;
1866 input_stream = stream;
1867 ReInitRounds();
1868 }
1869 private void ReInitRounds()
1870 {
1871 int i;
1872 jjround = 0x80000001;
1873 for (i = 68; i-- > 0;)
1874 jjrounds[i] = 0x80000000;
1875 }
1876
1877 /** Reinitialise parser. */
1878 public void ReInit(CharStream stream, int lexState)
1879 {
1880 ReInit(stream);
1881 SwitchTo(lexState);
1882 }
1883
1884 /** Switch to specified lex state. */
1885 public void SwitchTo(int lexState)
1886 {
1887 if (lexState >= 3 || lexState < 0)
1888 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1889 else
1890 curLexState = lexState;
1891 }
1892
1893 protected Token jjFillToken()
1894 {
1895 final Token t;
1896 final String curTokenImage;
1897 final int beginLine;
1898 final int endLine;
1899 final int beginColumn;
1900 final int endColumn;
1901 String im = jjstrLiteralImages[jjmatchedKind];
1902 curTokenImage = (im == null) ? input_stream.GetImage() : im;
1903 beginLine = input_stream.getBeginLine();
1904 beginColumn = input_stream.getBeginColumn();
1905 endLine = input_stream.getEndLine();
1906 endColumn = input_stream.getEndColumn();
1907 t = Token.newToken(jjmatchedKind, curTokenImage);
1908
1909 t.beginLine = beginLine;
1910 t.endLine = endLine;
1911 t.beginColumn = beginColumn;
1912 t.endColumn = endColumn;
1913
1914 return t;
1915 }
1916
1917 int curLexState = 0;
1918 int defaultLexState = 0;
1919 int jjnewStateCnt;
1920 int jjround;
1921 int jjmatchedPos;
1922 int jjmatchedKind;
1923
1924 /** Get the next Token. */
1925 public Token getNextToken()
1926 {
1927 Token specialToken = null;
1928 Token matchedToken;
1929 int curPos = 0;
1930
1931 EOFLoop :
1932 for (;;)
1933 {
1934 try
1935 {
1936 curChar = input_stream.BeginToken();
1937 }
1938 catch(java.io.IOException e)
1939 {
1940 jjmatchedKind = 0;
1941 matchedToken = jjFillToken();
1942 matchedToken.specialToken = specialToken;
1943 return matchedToken;
1944 }
1945 image = jjimage;
1946 image.setLength(0);
1947 jjimageLen = 0;
1948
1949 for (;;)
1950 {
1951 switch(curLexState)
1952 {
1953 case 0:
1954 jjmatchedKind = 0x7fffffff;
1955 jjmatchedPos = 0;
1956 curPos = jjMoveStringLiteralDfa0_0();
1957 break;
1958 case 1:
1959 jjmatchedKind = 0x7fffffff;
1960 jjmatchedPos = 0;
1961 curPos = jjMoveStringLiteralDfa0_1();
1962 if (jjmatchedPos == 0 && jjmatchedKind > 11)
1963 {
1964 jjmatchedKind = 11;
1965 }
1966 break;
1967 case 2:
1968 jjmatchedKind = 0x7fffffff;
1969 jjmatchedPos = 0;
1970 curPos = jjMoveStringLiteralDfa0_2();
1971 if (jjmatchedPos == 0 && jjmatchedKind > 11)
1972 {
1973 jjmatchedKind = 11;
1974 }
1975 break;
1976 }
1977 if (jjmatchedKind != 0x7fffffff)
1978 {
1979 if (jjmatchedPos + 1 < curPos)
1980 input_stream.backup(curPos - jjmatchedPos - 1);
1981 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1982 {
1983 matchedToken = jjFillToken();
1984 matchedToken.specialToken = specialToken;
1985 TokenLexicalActions(matchedToken);
1986 if (jjnewLexState[jjmatchedKind] != -1)
1987 curLexState = jjnewLexState[jjmatchedKind];
1988 return matchedToken;
1989 }
1990 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1991 {
1992 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1993 {
1994 matchedToken = jjFillToken();
1995 if (specialToken == null)
1996 specialToken = matchedToken;
1997 else
1998 {
1999 matchedToken.specialToken = specialToken;
2000 specialToken = (specialToken.next = matchedToken);
2001 }
2002 SkipLexicalActions(matchedToken);
2003 }
2004 else
2005 SkipLexicalActions(null);
2006 if (jjnewLexState[jjmatchedKind] != -1)
2007 curLexState = jjnewLexState[jjmatchedKind];
2008 continue EOFLoop;
2009 }
2010 MoreLexicalActions();
2011 if (jjnewLexState[jjmatchedKind] != -1)
2012 curLexState = jjnewLexState[jjmatchedKind];
2013 curPos = 0;
2014 jjmatchedKind = 0x7fffffff;
2015 try {
2016 curChar = input_stream.readChar();
2017 continue;
2018 }
2019 catch (java.io.IOException e1) { }
2020 }
2021 int error_line = input_stream.getEndLine();
2022 int error_column = input_stream.getEndColumn();
2023 String error_after = null;
2024 boolean EOFSeen = false;
2025 try { input_stream.readChar(); input_stream.backup(1); }
2026 catch (java.io.IOException e1) {
2027 EOFSeen = true;
2028 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2029 if (curChar == '\n' || curChar == '\r') {
2030 error_line++;
2031 error_column = 0;
2032 }
2033 else
2034 error_column++;
2035 }
2036 if (!EOFSeen) {
2037 input_stream.backup(1);
2038 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2039 }
2040 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2041 }
2042 }
2043 }
2044
2045 void SkipLexicalActions(Token matchedToken)
2046 {
2047 switch(jjmatchedKind)
2048 {
2049 case 6 :
2050 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2051 int startOfNOPMD = matchedToken.image.indexOf(excludeMarker);
2052 if (startOfNOPMD != -1) {
2053 excludeMap.put(matchedToken.beginLine, matchedToken.image.substring(startOfNOPMD + excludeMarker.length()));
2054 }
2055 comments.add(new SingleLineComment(matchedToken));
2056 break;
2057 case 9 :
2058 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2059 comments.add(new FormalComment(matchedToken));
2060 break;
2061 case 10 :
2062 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2063 comments.add(new MultiLineComment(matchedToken));
2064 break;
2065 default :
2066 break;
2067 }
2068 }
2069 void MoreLexicalActions()
2070 {
2071 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2072 switch(jjmatchedKind)
2073 {
2074 case 7 :
2075 image.append(input_stream.GetSuffix(jjimageLen));
2076 jjimageLen = 0;
2077 input_stream.backup(1);
2078 break;
2079 default :
2080 break;
2081 }
2082 }
2083 void TokenLexicalActions(Token matchedToken)
2084 {
2085 switch(jjmatchedKind)
2086 {
2087 case 120 :
2088 image.append(jjstrLiteralImages[120]);
2089 lengthOfMatch = jjstrLiteralImages[120].length();
2090 matchedToken.kind = GT;
2091 ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT;
2092 input_stream.backup(2);
2093 matchedToken.image = ">";
2094 break;
2095 case 121 :
2096 image.append(jjstrLiteralImages[121]);
2097 lengthOfMatch = jjstrLiteralImages[121].length();
2098 matchedToken.kind = GT;
2099 ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT;
2100 input_stream.backup(1);
2101 matchedToken.image = ">";
2102 break;
2103 default :
2104 break;
2105 }
2106 }
2107 private void jjCheckNAdd(int state)
2108 {
2109 if (jjrounds[state] != jjround)
2110 {
2111 jjstateSet[jjnewStateCnt++] = state;
2112 jjrounds[state] = jjround;
2113 }
2114 }
2115 private void jjAddStates(int start, int end)
2116 {
2117 do {
2118 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2119 } while (start++ != end);
2120 }
2121 private void jjCheckNAddTwoStates(int state1, int state2)
2122 {
2123 jjCheckNAdd(state1);
2124 jjCheckNAdd(state2);
2125 }
2126
2127 private void jjCheckNAddStates(int start, int end)
2128 {
2129 do {
2130 jjCheckNAdd(jjnextStates[start]);
2131 } while (start++ != end);
2132 }
2133
2134 }