1
2 package net.sourceforge.pmd.lang.java.ast;
3 import java.util.ArrayList;
4 import java.util.List;
5 import java.util.Map;
6 import net.sourceforge.pmd.lang.ast.CharStream;
7 import net.sourceforge.pmd.lang.ast.TokenMgrError;
8
9
10 public class JavaParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements JavaParserConstants
11 {
12 protected List<Comment> comments = new ArrayList<Comment>();
13
14
15 public java.io.PrintStream debugStream = System.out;
16
17 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
18 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2)
19 {
20 switch (pos)
21 {
22 case 0:
23 if ((active0 & 0x100L) != 0L || (active1 & 0x1008000000000L) != 0L)
24 return 31;
25 if ((active1 & 0x100000000100000L) != 0L)
26 return 1;
27 if ((active0 & 0x7ffffffffffff000L) != 0L)
28 {
29 jjmatchedKind = 73;
30 return 29;
31 }
32 return -1;
33 case 1:
34 if ((active0 & 0x7ffffffdfe7ff000L) != 0L)
35 {
36 if (jjmatchedPos != 1)
37 {
38 jjmatchedKind = 73;
39 jjmatchedPos = 1;
40 }
41 return 29;
42 }
43 if ((active0 & 0x100L) != 0L)
44 return 36;
45 if ((active0 & 0x201800000L) != 0L)
46 return 29;
47 return -1;
48 case 2:
49 if ((active0 & 0x7bfffd9d7f7ff000L) != 0L)
50 {
51 if (jjmatchedPos != 2)
52 {
53 jjmatchedKind = 73;
54 jjmatchedPos = 2;
55 }
56 return 29;
57 }
58 if ((active0 & 0x400026080000000L) != 0L)
59 return 29;
60 return -1;
61 case 3:
62 if ((active0 & 0x71dff95c7d7a7000L) != 0L)
63 {
64 jjmatchedKind = 73;
65 jjmatchedPos = 3;
66 return 29;
67 }
68 if ((active0 & 0xa20048102058000L) != 0L)
69 return 29;
70 return -1;
71 case 4:
72 if ((active0 & 0x20c50000781a4000L) != 0L)
73 return 29;
74 if ((active0 & 0x511af95c05603000L) != 0L)
75 {
76 if (jjmatchedPos != 4)
77 {
78 jjmatchedKind = 73;
79 jjmatchedPos = 4;
80 }
81 return 29;
82 }
83 return -1;
84 case 5:
85 if ((active0 & 0x5110385424603000L) != 0L)
86 {
87 jjmatchedKind = 73;
88 jjmatchedPos = 5;
89 return 29;
90 }
91 if ((active0 & 0x8ac10801000000L) != 0L)
92 return 29;
93 return -1;
94 case 6:
95 if ((active0 & 0x5110205400201000L) != 0L)
96 {
97 jjmatchedKind = 73;
98 jjmatchedPos = 6;
99 return 29;
100 }
101 if ((active0 & 0x180024402000L) != 0L)
102 return 29;
103 return -1;
104 case 7:
105 if ((active0 & 0x5000000000201000L) != 0L)
106 return 29;
107 if ((active0 & 0x110205400000000L) != 0L)
108 {
109 jjmatchedKind = 73;
110 jjmatchedPos = 7;
111 return 29;
112 }
113 return -1;
114 case 8:
115 if ((active0 & 0x10001400000000L) != 0L)
116 {
117 jjmatchedKind = 73;
118 jjmatchedPos = 8;
119 return 29;
120 }
121 if ((active0 & 0x100204000000000L) != 0L)
122 return 29;
123 return -1;
124 case 9:
125 if ((active0 & 0x10000000000000L) != 0L)
126 {
127 jjmatchedKind = 73;
128 jjmatchedPos = 9;
129 return 29;
130 }
131 if ((active0 & 0x1400000000L) != 0L)
132 return 29;
133 return -1;
134 case 10:
135 if ((active0 & 0x10000000000000L) != 0L)
136 {
137 jjmatchedKind = 73;
138 jjmatchedPos = 10;
139 return 29;
140 }
141 return -1;
142 default :
143 return -1;
144 }
145 }
146 private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
147 {
148 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
149 }
150 private int jjStopAtPos(int pos, int kind)
151 {
152 jjmatchedKind = kind;
153 jjmatchedPos = pos;
154 return pos + 1;
155 }
156 private int jjMoveStringLiteralDfa0_0()
157 {
158 switch(curChar)
159 {
160 case 9:
161 return jjStopAtPos(0, 2);
162 case 10:
163 return jjStopAtPos(0, 3);
164 case 12:
165 return jjStopAtPos(0, 5);
166 case 13:
167 return jjStopAtPos(0, 4);
168 case 26:
169 return jjStopAtPos(0, 126);
170 case 32:
171 return jjStopAtPos(0, 1);
172 case 33:
173 jjmatchedKind = 88;
174 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
175 case 37:
176 jjmatchedKind = 107;
177 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L);
178 case 38:
179 jjmatchedKind = 104;
180 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000200000000L);
181 case 40:
182 return jjStopAtPos(0, 76);
183 case 41:
184 return jjStopAtPos(0, 77);
185 case 42:
186 jjmatchedKind = 102;
187 return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L);
188 case 43:
189 jjmatchedKind = 100;
190 return jjMoveStringLiteralDfa1_0(0x0L, 0x200400000000L);
191 case 44:
192 return jjStopAtPos(0, 83);
193 case 45:
194 jjmatchedKind = 101;
195 return jjMoveStringLiteralDfa1_0(0x0L, 0x200400800000000L);
196 case 46:
197 jjmatchedKind = 84;
198 return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L);
199 case 47:
200 jjmatchedKind = 103;
201 return jjMoveStringLiteralDfa1_0(0x100L, 0x1000000000000L);
202 case 58:
203 jjmatchedKind = 91;
204 return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000000L);
205 case 59:
206 return jjStopAtPos(0, 82);
207 case 60:
208 jjmatchedKind = 87;
209 return jjMoveStringLiteralDfa1_0(0x0L, 0x20100020000000L);
210 case 61:
211 jjmatchedKind = 86;
212 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
213 case 62:
214 jjmatchedKind = 125;
215 return jjMoveStringLiteralDfa1_0(0x0L, 0x18c0000040000000L);
216 case 63:
217 return jjStopAtPos(0, 90);
218 case 64:
219 return jjStopAtPos(0, 85);
220 case 91:
221 return jjStopAtPos(0, 80);
222 case 93:
223 return jjStopAtPos(0, 81);
224 case 94:
225 jjmatchedKind = 106;
226 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
227 case 97:
228 return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
229 case 98:
230 return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);
231 case 99:
232 return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);
233 case 100:
234 return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
235 case 101:
236 return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);
237 case 102:
238 return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);
239 case 103:
240 return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
241 case 105:
242 return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);
243 case 108:
244 return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
245 case 110:
246 return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);
247 case 112:
248 return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);
249 case 114:
250 return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);
251 case 115:
252 return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);
253 case 116:
254 return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);
255 case 118:
256 return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);
257 case 119:
258 return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
259 case 123:
260 return jjStopAtPos(0, 78);
261 case 124:
262 jjmatchedKind = 105;
263 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000100000000L);
264 case 125:
265 return jjStopAtPos(0, 79);
266 case 126:
267 jjmatchedKind = 89;
268 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000000L);
269 default :
270 return jjMoveNfa_0(0, 0);
271 }
272 }
273 private int jjMoveStringLiteralDfa1_0(long active0, long active1)
274 {
275 try { curChar = input_stream.readChar(); }
276 catch(java.io.IOException e) {
277 jjStopStringLiteralDfa_0(0, active0, active1, 0L);
278 return 1;
279 }
280 switch(curChar)
281 {
282 case 38:
283 if ((active1 & 0x200000000L) != 0L)
284 return jjStopAtPos(1, 97);
285 break;
286 case 42:
287 if ((active0 & 0x100L) != 0L)
288 return jjStartNfaWithStates_0(1, 8, 36);
289 break;
290 case 43:
291 if ((active1 & 0x400000000L) != 0L)
292 return jjStopAtPos(1, 98);
293 break;
294 case 45:
295 if ((active1 & 0x800000000L) != 0L)
296 return jjStopAtPos(1, 99);
297 break;
298 case 46:
299 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100000000000000L);
300 case 58:
301 if ((active1 & 0x400000000000000L) != 0L)
302 return jjStopAtPos(1, 122);
303 break;
304 case 60:
305 if ((active1 & 0x100000000000L) != 0L)
306 {
307 jjmatchedKind = 108;
308 jjmatchedPos = 1;
309 }
310 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000000000000L);
311 case 61:
312 if ((active1 & 0x10000000L) != 0L)
313 return jjStopAtPos(1, 92);
314 else if ((active1 & 0x20000000L) != 0L)
315 return jjStopAtPos(1, 93);
316 else if ((active1 & 0x40000000L) != 0L)
317 return jjStopAtPos(1, 94);
318 else if ((active1 & 0x80000000L) != 0L)
319 return jjStopAtPos(1, 95);
320 else if ((active1 & 0x200000000000L) != 0L)
321 return jjStopAtPos(1, 109);
322 else if ((active1 & 0x400000000000L) != 0L)
323 return jjStopAtPos(1, 110);
324 else if ((active1 & 0x800000000000L) != 0L)
325 return jjStopAtPos(1, 111);
326 else if ((active1 & 0x1000000000000L) != 0L)
327 return jjStopAtPos(1, 112);
328 else if ((active1 & 0x2000000000000L) != 0L)
329 return jjStopAtPos(1, 113);
330 else if ((active1 & 0x4000000000000L) != 0L)
331 return jjStopAtPos(1, 114);
332 else if ((active1 & 0x8000000000000L) != 0L)
333 return jjStopAtPos(1, 115);
334 else if ((active1 & 0x10000000000000L) != 0L)
335 return jjStopAtPos(1, 116);
336 break;
337 case 62:
338 if ((active1 & 0x200000000000000L) != 0L)
339 return jjStopAtPos(1, 121);
340 else if ((active1 & 0x1000000000000000L) != 0L)
341 {
342 jjmatchedKind = 124;
343 jjmatchedPos = 1;
344 }
345 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8c0000000000000L);
346 case 91:
347 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000000000000000L);
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, 29);
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 & 0x100000000L) != 0L)
389 return jjStopAtPos(1, 96);
390 break;
391 default :
392 break;
393 }
394 return jjStartNfa_0(0, active0, active1, 0L);
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, 0L);
400 try { curChar = input_stream.readChar(); }
401 catch(java.io.IOException e) {
402 jjStopStringLiteralDfa_0(1, active0, active1, 0L);
403 return 2;
404 }
405 switch(curChar)
406 {
407 case 46:
408 if ((active1 & 0x100000000000000L) != 0L)
409 return jjStopAtPos(2, 120);
410 break;
411 case 61:
412 if ((active1 & 0x20000000000000L) != 0L)
413 return jjStopAtPos(2, 117);
414 else if ((active1 & 0x40000000000000L) != 0L)
415 return jjStopAtPos(2, 118);
416 break;
417 case 62:
418 if ((active1 & 0x800000000000000L) != 0L)
419 {
420 jjmatchedKind = 123;
421 jjmatchedPos = 2;
422 }
423 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x80000000000000L);
424 case 93:
425 if ((active1 & 0x8000000000000000L) != 0L)
426 return jjStopAtPos(2, 127);
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, 29);
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, 29);
466 break;
467 case 121:
468 if ((active0 & 0x400000000000000L) != 0L)
469 return jjStartNfaWithStates_0(2, 58, 29);
470 break;
471 default :
472 break;
473 }
474 return jjStartNfa_0(1, active0, active1, 0L);
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, 0L);
480 try { curChar = input_stream.readChar(); }
481 catch(java.io.IOException e) {
482 jjStopStringLiteralDfa_0(2, active0, active1, 0L);
483 return 3;
484 }
485 switch(curChar)
486 {
487 case 61:
488 if ((active1 & 0x80000000000000L) != 0L)
489 return jjStopAtPos(3, 119);
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, 29);
500 break;
501 case 101:
502 if ((active0 & 0x8000L) != 0L)
503 return jjStartNfaWithStates_0(3, 15, 29);
504 else if ((active0 & 0x10000L) != 0L)
505 return jjStartNfaWithStates_0(3, 16, 29);
506 else if ((active0 & 0x2000000L) != 0L)
507 return jjStartNfaWithStates_0(3, 25, 29);
508 else if ((active0 & 0x200000000000000L) != 0L)
509 return jjStartNfaWithStates_0(3, 57, 29);
510 return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L, active1, 0L);
511 case 103:
512 if ((active0 & 0x8000000000L) != 0L)
513 return jjStartNfaWithStates_0(3, 39, 29);
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, 29);
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, 29);
528 return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0L);
529 case 114:
530 if ((active0 & 0x40000L) != 0L)
531 return jjStartNfaWithStates_0(3, 18, 29);
532 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
533 case 115:
534 if ((active0 & 0x20000000000000L) != 0L)
535 return jjStartNfaWithStates_0(3, 53, 29);
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, 0L);
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, 0L);
552 try { curChar = input_stream.readChar(); }
553 catch(java.io.IOException e) {
554 jjStopStringLiteralDfa_0(3, active0, 0L, 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, 29);
566 else if ((active0 & 0x2000000000000000L) != 0L)
567 return jjStartNfaWithStates_0(4, 61, 29);
568 return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);
569 case 104:
570 if ((active0 & 0x20000L) != 0L)
571 return jjStartNfaWithStates_0(4, 17, 29);
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, 29);
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, 29);
591 return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);
592 case 115:
593 if ((active0 & 0x80000L) != 0L)
594 return jjStartNfaWithStates_0(4, 19, 29);
595 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);
596 case 116:
597 if ((active0 & 0x100000L) != 0L)
598 return jjStartNfaWithStates_0(4, 20, 29);
599 else if ((active0 & 0x40000000L) != 0L)
600 return jjStartNfaWithStates_0(4, 30, 29);
601 else if ((active0 & 0x1000000000000L) != 0L)
602 return jjStartNfaWithStates_0(4, 48, 29);
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, 0L);
619 }
620 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
621 {
622 if (((active0 &= old0)) == 0L)
623 return jjStartNfa_0(3, old0, 0L, 0L);
624 try { curChar = input_stream.readChar(); }
625 catch(java.io.IOException e) {
626 jjStopStringLiteralDfa_0(4, active0, 0L, 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, 29);
636 else if ((active0 & 0x2000000000000L) != 0L)
637 return jjStartNfaWithStates_0(5, 49, 29);
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, 29);
644 else if ((active0 & 0x10000000000L) != 0L)
645 return jjStartNfaWithStates_0(5, 40, 29);
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, 29);
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, 29);
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, 29);
670 break;
671 case 116:
672 if ((active0 & 0x800000000L) != 0L)
673 return jjStartNfaWithStates_0(5, 35, 29);
674 return jjMoveStringLiteralDfa6_0(active0, 0x4000100000000000L);
675 default :
676 break;
677 }
678 return jjStartNfa_0(4, active0, 0L, 0L);
679 }
680 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
681 {
682 if (((active0 &= old0)) == 0L)
683 return jjStartNfa_0(4, old0, 0L, 0L);
684 try { curChar = input_stream.readChar(); }
685 catch(java.io.IOException e) {
686 jjStopStringLiteralDfa_0(5, active0, 0L, 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, 29);
698 else if ((active0 & 0x100000000000L) != 0L)
699 return jjStartNfaWithStates_0(6, 44, 29);
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, 29);
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, 29);
714 break;
715 case 116:
716 if ((active0 & 0x400000L) != 0L)
717 return jjStartNfaWithStates_0(6, 22, 29);
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, 29);
724 break;
725 default :
726 break;
727 }
728 return jjStartNfa_0(5, active0, 0L, 0L);
729 }
730 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
731 {
732 if (((active0 &= old0)) == 0L)
733 return jjStartNfa_0(5, old0, 0L, 0L);
734 try { curChar = input_stream.readChar(); }
735 catch(java.io.IOException e) {
736 jjStopStringLiteralDfa_0(6, active0, 0L, 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, 29);
746 else if ((active0 & 0x1000000000000000L) != 0L)
747 return jjStartNfaWithStates_0(7, 60, 29);
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, 29);
754 break;
755 case 116:
756 if ((active0 & 0x1000L) != 0L)
757 return jjStartNfaWithStates_0(7, 12, 29);
758 break;
759 default :
760 break;
761 }
762 return jjStartNfa_0(6, active0, 0L, 0L);
763 }
764 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
765 {
766 if (((active0 &= old0)) == 0L)
767 return jjStartNfa_0(6, old0, 0L, 0L);
768 try { curChar = input_stream.readChar(); }
769 catch(java.io.IOException e) {
770 jjStopStringLiteralDfa_0(7, active0, 0L, 0L);
771 return 8;
772 }
773 switch(curChar)
774 {
775 case 100:
776 if ((active0 & 0x200000000000L) != 0L)
777 return jjStartNfaWithStates_0(8, 45, 29);
778 break;
779 case 101:
780 if ((active0 & 0x4000000000L) != 0L)
781 return jjStartNfaWithStates_0(8, 38, 29);
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, 29);
790 return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
791 default :
792 break;
793 }
794 return jjStartNfa_0(7, active0, 0L, 0L);
795 }
796 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
797 {
798 if (((active0 &= old0)) == 0L)
799 return jjStartNfa_0(7, old0, 0L, 0L);
800 try { curChar = input_stream.readChar(); }
801 catch(java.io.IOException e) {
802 jjStopStringLiteralDfa_0(8, active0, 0L, 0L);
803 return 9;
804 }
805 switch(curChar)
806 {
807 case 102:
808 if ((active0 & 0x1000000000L) != 0L)
809 return jjStartNfaWithStates_0(9, 36, 29);
810 break;
811 case 115:
812 if ((active0 & 0x400000000L) != 0L)
813 return jjStartNfaWithStates_0(9, 34, 29);
814 break;
815 case 122:
816 return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L);
817 default :
818 break;
819 }
820 return jjStartNfa_0(8, active0, 0L, 0L);
821 }
822 private int jjMoveStringLiteralDfa10_0(long old0, long active0)
823 {
824 if (((active0 &= old0)) == 0L)
825 return jjStartNfa_0(8, old0, 0L, 0L);
826 try { curChar = input_stream.readChar(); }
827 catch(java.io.IOException e) {
828 jjStopStringLiteralDfa_0(9, active0, 0L, 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, 0L);
839 }
840 private int jjMoveStringLiteralDfa11_0(long old0, long active0)
841 {
842 if (((active0 &= old0)) == 0L)
843 return jjStartNfa_0(9, old0, 0L, 0L);
844 try { curChar = input_stream.readChar(); }
845 catch(java.io.IOException e) {
846 jjStopStringLiteralDfa_0(10, active0, 0L, 0L);
847 return 11;
848 }
849 switch(curChar)
850 {
851 case 100:
852 if ((active0 & 0x10000000000000L) != 0L)
853 return jjStartNfaWithStates_0(11, 52, 29);
854 break;
855 default :
856 break;
857 }
858 return jjStartNfa_0(10, active0, 0L, 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 = 99;
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 31:
1070 if (curChar == 42)
1071 jjstateSet[jjnewStateCnt++] = 36;
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 {
1082 if (kind > 63)
1083 kind = 63;
1084 jjCheckNAddStates(3, 15);
1085 }
1086 else if (curChar == 47)
1087 jjAddStates(16, 17);
1088 else if (curChar == 36)
1089 {
1090 if (kind > 73)
1091 kind = 73;
1092 jjCheckNAdd(29);
1093 }
1094 else if (curChar == 34)
1095 jjCheckNAddStates(18, 20);
1096 else if (curChar == 39)
1097 jjAddStates(21, 22);
1098 else if (curChar == 46)
1099 jjstateSet[jjnewStateCnt++] = 1;
1100 if (curChar == 48)
1101 jjAddStates(23, 27);
1102 break;
1103 case 1:
1104 if ((0x3ff000000000000L & l) == 0L)
1105 break;
1106 if (kind > 68)
1107 kind = 68;
1108 jjCheckNAddStates(28, 31);
1109 break;
1110 case 2:
1111 if ((0x3ff000000000000L & l) != 0L)
1112 jjCheckNAddTwoStates(2, 3);
1113 break;
1114 case 3:
1115 if ((0x3ff000000000000L & l) == 0L)
1116 break;
1117 if (kind > 68)
1118 kind = 68;
1119 jjCheckNAddTwoStates(4, 9);
1120 break;
1121 case 5:
1122 if ((0x280000000000L & l) != 0L)
1123 jjstateSet[jjnewStateCnt++] = 6;
1124 break;
1125 case 6:
1126 if ((0x3ff000000000000L & l) == 0L)
1127 break;
1128 if (kind > 68)
1129 kind = 68;
1130 jjCheckNAddStates(32, 34);
1131 break;
1132 case 7:
1133 if ((0x3ff000000000000L & l) != 0L)
1134 jjCheckNAddTwoStates(7, 8);
1135 break;
1136 case 8:
1137 case 53:
1138 case 60:
1139 if ((0x3ff000000000000L & l) == 0L)
1140 break;
1141 if (kind > 68)
1142 kind = 68;
1143 jjCheckNAdd(9);
1144 break;
1145 case 10:
1146 if (curChar == 39)
1147 jjAddStates(21, 22);
1148 break;
1149 case 11:
1150 if ((0xffffff7fffffdbffL & l) != 0L)
1151 jjCheckNAdd(12);
1152 break;
1153 case 12:
1154 if (curChar == 39 && kind > 71)
1155 kind = 71;
1156 break;
1157 case 14:
1158 if ((0x8400000000L & l) != 0L)
1159 jjCheckNAdd(12);
1160 break;
1161 case 15:
1162 if ((0xff000000000000L & l) != 0L)
1163 jjCheckNAddTwoStates(16, 12);
1164 break;
1165 case 16:
1166 if ((0xff000000000000L & l) != 0L)
1167 jjCheckNAdd(12);
1168 break;
1169 case 17:
1170 if ((0xf000000000000L & l) != 0L)
1171 jjstateSet[jjnewStateCnt++] = 18;
1172 break;
1173 case 18:
1174 if ((0xff000000000000L & l) != 0L)
1175 jjCheckNAdd(16);
1176 break;
1177 case 19:
1178 if (curChar == 34)
1179 jjCheckNAddStates(18, 20);
1180 break;
1181 case 20:
1182 if ((0xfffffffbffffdbffL & l) != 0L)
1183 jjCheckNAddStates(18, 20);
1184 break;
1185 case 22:
1186 if ((0x8400000000L & l) != 0L)
1187 jjCheckNAddStates(18, 20);
1188 break;
1189 case 23:
1190 if (curChar == 34 && kind > 72)
1191 kind = 72;
1192 break;
1193 case 24:
1194 if ((0xff000000000000L & l) != 0L)
1195 jjCheckNAddStates(35, 38);
1196 break;
1197 case 25:
1198 if ((0xff000000000000L & l) != 0L)
1199 jjCheckNAddStates(18, 20);
1200 break;
1201 case 26:
1202 if ((0xf000000000000L & l) != 0L)
1203 jjstateSet[jjnewStateCnt++] = 27;
1204 break;
1205 case 27:
1206 if ((0xff000000000000L & l) != 0L)
1207 jjCheckNAdd(25);
1208 break;
1209 case 28:
1210 if (curChar != 36)
1211 break;
1212 if (kind > 73)
1213 kind = 73;
1214 jjCheckNAdd(29);
1215 break;
1216 case 29:
1217 if ((0x3ff00100fffc1ffL & l) == 0L)
1218 break;
1219 if (kind > 73)
1220 kind = 73;
1221 jjCheckNAdd(29);
1222 break;
1223 case 30:
1224 if (curChar == 47)
1225 jjAddStates(16, 17);
1226 break;
1227 case 32:
1228 if ((0xffffffffffffdbffL & l) == 0L)
1229 break;
1230 if (kind > 6)
1231 kind = 6;
1232 jjCheckNAddStates(0, 2);
1233 break;
1234 case 33:
1235 if ((0x2400L & l) != 0L && kind > 6)
1236 kind = 6;
1237 break;
1238 case 34:
1239 if (curChar == 10 && kind > 6)
1240 kind = 6;
1241 break;
1242 case 35:
1243 if (curChar == 13)
1244 jjstateSet[jjnewStateCnt++] = 34;
1245 break;
1246 case 36:
1247 if (curChar == 42)
1248 jjstateSet[jjnewStateCnt++] = 37;
1249 break;
1250 case 37:
1251 if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1252 kind = 7;
1253 break;
1254 case 38:
1255 if (curChar == 42)
1256 jjstateSet[jjnewStateCnt++] = 36;
1257 break;
1258 case 39:
1259 if ((0x3ff000000000000L & l) == 0L)
1260 break;
1261 if (kind > 63)
1262 kind = 63;
1263 jjCheckNAddStates(3, 15);
1264 break;
1265 case 40:
1266 if ((0x3ff000000000000L & l) != 0L)
1267 jjCheckNAddTwoStates(40, 41);
1268 break;
1269 case 41:
1270 case 72:
1271 if ((0x3ff000000000000L & l) == 0L)
1272 break;
1273 if (kind > 63)
1274 kind = 63;
1275 jjCheckNAdd(42);
1276 break;
1277 case 43:
1278 if ((0x3ff000000000000L & l) != 0L)
1279 jjCheckNAddTwoStates(43, 44);
1280 break;
1281 case 44:
1282 if ((0x3ff000000000000L & l) != 0L)
1283 jjCheckNAdd(45);
1284 break;
1285 case 45:
1286 if (curChar != 46)
1287 break;
1288 if (kind > 68)
1289 kind = 68;
1290 jjCheckNAddStates(39, 41);
1291 break;
1292 case 46:
1293 if ((0x3ff000000000000L & l) == 0L)
1294 break;
1295 if (kind > 68)
1296 kind = 68;
1297 jjCheckNAddStates(42, 45);
1298 break;
1299 case 47:
1300 if ((0x3ff000000000000L & l) != 0L)
1301 jjCheckNAddTwoStates(47, 48);
1302 break;
1303 case 48:
1304 if ((0x3ff000000000000L & l) == 0L)
1305 break;
1306 if (kind > 68)
1307 kind = 68;
1308 jjCheckNAddTwoStates(49, 9);
1309 break;
1310 case 50:
1311 if ((0x280000000000L & l) != 0L)
1312 jjstateSet[jjnewStateCnt++] = 51;
1313 break;
1314 case 51:
1315 if ((0x3ff000000000000L & l) == 0L)
1316 break;
1317 if (kind > 68)
1318 kind = 68;
1319 jjCheckNAddStates(46, 48);
1320 break;
1321 case 52:
1322 if ((0x3ff000000000000L & l) != 0L)
1323 jjCheckNAddTwoStates(52, 53);
1324 break;
1325 case 54:
1326 if ((0x3ff000000000000L & l) != 0L)
1327 jjCheckNAddTwoStates(54, 55);
1328 break;
1329 case 55:
1330 if ((0x3ff000000000000L & l) != 0L)
1331 jjCheckNAdd(56);
1332 break;
1333 case 57:
1334 if ((0x280000000000L & l) != 0L)
1335 jjstateSet[jjnewStateCnt++] = 58;
1336 break;
1337 case 58:
1338 if ((0x3ff000000000000L & l) == 0L)
1339 break;
1340 if (kind > 68)
1341 kind = 68;
1342 jjCheckNAddStates(49, 51);
1343 break;
1344 case 59:
1345 if ((0x3ff000000000000L & l) != 0L)
1346 jjCheckNAddTwoStates(59, 60);
1347 break;
1348 case 61:
1349 if ((0x3ff000000000000L & l) != 0L)
1350 jjCheckNAddTwoStates(61, 62);
1351 break;
1352 case 62:
1353 if ((0x3ff000000000000L & l) != 0L)
1354 jjCheckNAddTwoStates(63, 9);
1355 break;
1356 case 64:
1357 if ((0x280000000000L & l) != 0L)
1358 jjstateSet[jjnewStateCnt++] = 65;
1359 break;
1360 case 65:
1361 if ((0x3ff000000000000L & l) != 0L)
1362 jjCheckNAddStates(52, 54);
1363 break;
1364 case 66:
1365 if ((0x3ff000000000000L & l) != 0L)
1366 jjCheckNAddTwoStates(66, 67);
1367 break;
1368 case 67:
1369 if ((0x3ff000000000000L & l) != 0L)
1370 jjCheckNAdd(9);
1371 break;
1372 case 68:
1373 if (curChar == 48)
1374 jjAddStates(23, 27);
1375 break;
1376 case 70:
1377 if ((0x3ff000000000000L & l) == 0L)
1378 break;
1379 if (kind > 63)
1380 kind = 63;
1381 jjCheckNAddStates(55, 57);
1382 break;
1383 case 71:
1384 if ((0x3ff000000000000L & l) != 0L)
1385 jjCheckNAddTwoStates(71, 72);
1386 break;
1387 case 74:
1388 if ((0x3000000000000L & l) == 0L)
1389 break;
1390 if (kind > 63)
1391 kind = 63;
1392 jjCheckNAddStates(58, 60);
1393 break;
1394 case 75:
1395 if ((0x3000000000000L & l) != 0L)
1396 jjCheckNAddTwoStates(75, 76);
1397 break;
1398 case 76:
1399 if ((0x3000000000000L & l) == 0L)
1400 break;
1401 if (kind > 63)
1402 kind = 63;
1403 jjCheckNAdd(42);
1404 break;
1405 case 77:
1406 if ((0xff000000000000L & l) == 0L)
1407 break;
1408 if (kind > 63)
1409 kind = 63;
1410 jjCheckNAddStates(61, 63);
1411 break;
1412 case 78:
1413 if ((0xff000000000000L & l) != 0L)
1414 jjCheckNAddTwoStates(78, 79);
1415 break;
1416 case 79:
1417 if ((0xff000000000000L & l) == 0L)
1418 break;
1419 if (kind > 63)
1420 kind = 63;
1421 jjCheckNAdd(42);
1422 break;
1423 case 81:
1424 if ((0x3ff000000000000L & l) != 0L)
1425 jjCheckNAddStates(64, 67);
1426 break;
1427 case 82:
1428 if ((0x3ff000000000000L & l) != 0L)
1429 jjCheckNAddTwoStates(82, 83);
1430 break;
1431 case 83:
1432 if ((0x3ff000000000000L & l) != 0L)
1433 jjCheckNAddTwoStates(84, 85);
1434 break;
1435 case 84:
1436 if (curChar == 46)
1437 jjCheckNAdd(85);
1438 break;
1439 case 86:
1440 if ((0x280000000000L & l) != 0L)
1441 jjstateSet[jjnewStateCnt++] = 87;
1442 break;
1443 case 87:
1444 if ((0x3ff000000000000L & l) == 0L)
1445 break;
1446 if (kind > 69)
1447 kind = 69;
1448 jjCheckNAddStates(68, 70);
1449 break;
1450 case 88:
1451 if ((0x3ff000000000000L & l) != 0L)
1452 jjCheckNAddTwoStates(88, 89);
1453 break;
1454 case 89:
1455 if ((0x3ff000000000000L & l) == 0L)
1456 break;
1457 if (kind > 69)
1458 kind = 69;
1459 jjCheckNAdd(90);
1460 break;
1461 case 92:
1462 if ((0x3ff000000000000L & l) != 0L)
1463 jjCheckNAddStates(71, 73);
1464 break;
1465 case 93:
1466 if ((0x3ff000000000000L & l) != 0L)
1467 jjCheckNAddTwoStates(93, 94);
1468 break;
1469 case 94:
1470 if ((0x3ff000000000000L & l) != 0L)
1471 jjCheckNAdd(95);
1472 break;
1473 case 95:
1474 if (curChar == 46)
1475 jjstateSet[jjnewStateCnt++] = 96;
1476 break;
1477 case 96:
1478 if ((0x3ff000000000000L & l) != 0L)
1479 jjCheckNAddStates(74, 76);
1480 break;
1481 case 97:
1482 if ((0x3ff000000000000L & l) != 0L)
1483 jjCheckNAddTwoStates(97, 98);
1484 break;
1485 case 98:
1486 if ((0x3ff000000000000L & l) != 0L)
1487 jjCheckNAdd(85);
1488 break;
1489 default : break;
1490 }
1491 } while(i != startsAt);
1492 }
1493 else if (curChar < 128)
1494 {
1495 long l = 1L << (curChar & 077);
1496 do
1497 {
1498 switch(jjstateSet[--i])
1499 {
1500 case 0:
1501 if ((0x7fffffe87fffffeL & l) == 0L)
1502 break;
1503 if (kind > 73)
1504 kind = 73;
1505 jjCheckNAdd(29);
1506 break;
1507 case 2:
1508 if (curChar == 95)
1509 jjAddStates(77, 78);
1510 break;
1511 case 4:
1512 if ((0x2000000020L & l) != 0L)
1513 jjAddStates(79, 80);
1514 break;
1515 case 7:
1516 if (curChar == 95)
1517 jjAddStates(81, 82);
1518 break;
1519 case 9:
1520 if ((0x5000000050L & l) != 0L && kind > 68)
1521 kind = 68;
1522 break;
1523 case 11:
1524 if ((0xffffffffefffffffL & l) != 0L)
1525 jjCheckNAdd(12);
1526 break;
1527 case 13:
1528 if (curChar == 92)
1529 jjAddStates(83, 85);
1530 break;
1531 case 14:
1532 if ((0x14404410000000L & l) != 0L)
1533 jjCheckNAdd(12);
1534 break;
1535 case 20:
1536 if ((0xffffffffefffffffL & l) != 0L)
1537 jjCheckNAddStates(18, 20);
1538 break;
1539 case 21:
1540 if (curChar == 92)
1541 jjAddStates(86, 88);
1542 break;
1543 case 22:
1544 if ((0x14404410000000L & l) != 0L)
1545 jjCheckNAddStates(18, 20);
1546 break;
1547 case 29:
1548 if ((0x87fffffe87fffffeL & l) == 0L)
1549 break;
1550 if (kind > 73)
1551 kind = 73;
1552 jjCheckNAdd(29);
1553 break;
1554 case 32:
1555 if (kind > 6)
1556 kind = 6;
1557 jjAddStates(0, 2);
1558 break;
1559 case 37:
1560 if (kind > 7)
1561 kind = 7;
1562 break;
1563 case 40:
1564 if (curChar == 95)
1565 jjAddStates(89, 90);
1566 break;
1567 case 42:
1568 if ((0x100000001000L & l) != 0L && kind > 63)
1569 kind = 63;
1570 break;
1571 case 43:
1572 if (curChar == 95)
1573 jjAddStates(91, 92);
1574 break;
1575 case 47:
1576 if (curChar == 95)
1577 jjAddStates(93, 94);
1578 break;
1579 case 49:
1580 if ((0x2000000020L & l) != 0L)
1581 jjAddStates(95, 96);
1582 break;
1583 case 52:
1584 if (curChar == 95)
1585 jjAddStates(97, 98);
1586 break;
1587 case 54:
1588 if (curChar == 95)
1589 jjAddStates(99, 100);
1590 break;
1591 case 56:
1592 if ((0x2000000020L & l) != 0L)
1593 jjAddStates(101, 102);
1594 break;
1595 case 59:
1596 if (curChar == 95)
1597 jjAddStates(103, 104);
1598 break;
1599 case 61:
1600 if (curChar == 95)
1601 jjAddStates(105, 106);
1602 break;
1603 case 63:
1604 if ((0x2000000020L & l) != 0L)
1605 jjAddStates(107, 108);
1606 break;
1607 case 66:
1608 if (curChar == 95)
1609 jjAddStates(109, 110);
1610 break;
1611 case 69:
1612 if ((0x100000001000000L & l) != 0L)
1613 jjstateSet[jjnewStateCnt++] = 70;
1614 break;
1615 case 70:
1616 if ((0x7e0000007eL & l) == 0L)
1617 break;
1618 if (kind > 63)
1619 kind = 63;
1620 jjCheckNAddStates(55, 57);
1621 break;
1622 case 71:
1623 if ((0x7e8000007eL & l) != 0L)
1624 jjCheckNAddTwoStates(71, 72);
1625 break;
1626 case 72:
1627 if ((0x7e0000007eL & l) == 0L)
1628 break;
1629 if (kind > 63)
1630 kind = 63;
1631 jjCheckNAdd(42);
1632 break;
1633 case 73:
1634 if ((0x400000004L & l) != 0L)
1635 jjstateSet[jjnewStateCnt++] = 74;
1636 break;
1637 case 75:
1638 if (curChar == 95)
1639 jjAddStates(111, 112);
1640 break;
1641 case 78:
1642 if (curChar == 95)
1643 jjAddStates(113, 114);
1644 break;
1645 case 80:
1646 if ((0x100000001000000L & l) != 0L)
1647 jjstateSet[jjnewStateCnt++] = 81;
1648 break;
1649 case 81:
1650 if ((0x7e0000007eL & l) != 0L)
1651 jjCheckNAddStates(64, 67);
1652 break;
1653 case 82:
1654 if ((0x7e8000007eL & l) != 0L)
1655 jjCheckNAddTwoStates(82, 83);
1656 break;
1657 case 83:
1658 if ((0x7e0000007eL & l) != 0L)
1659 jjCheckNAddTwoStates(84, 85);
1660 break;
1661 case 85:
1662 if ((0x1000000010000L & l) != 0L)
1663 jjAddStates(115, 116);
1664 break;
1665 case 88:
1666 if (curChar == 95)
1667 jjAddStates(117, 118);
1668 break;
1669 case 90:
1670 if ((0x5000000050L & l) != 0L && kind > 69)
1671 kind = 69;
1672 break;
1673 case 91:
1674 if ((0x100000001000000L & l) != 0L)
1675 jjCheckNAddTwoStates(92, 95);
1676 break;
1677 case 92:
1678 if ((0x7e0000007eL & l) != 0L)
1679 jjCheckNAddStates(71, 73);
1680 break;
1681 case 93:
1682 if ((0x7e8000007eL & l) != 0L)
1683 jjCheckNAddTwoStates(93, 94);
1684 break;
1685 case 94:
1686 if ((0x7e0000007eL & l) != 0L)
1687 jjCheckNAdd(95);
1688 break;
1689 case 96:
1690 if ((0x7e0000007eL & l) != 0L)
1691 jjCheckNAddStates(74, 76);
1692 break;
1693 case 97:
1694 if ((0x7e8000007eL & l) != 0L)
1695 jjCheckNAddTwoStates(97, 98);
1696 break;
1697 case 98:
1698 if ((0x7e0000007eL & l) != 0L)
1699 jjCheckNAdd(85);
1700 break;
1701 default : break;
1702 }
1703 } while(i != startsAt);
1704 }
1705 else
1706 {
1707 int hiByte = (int)(curChar >> 8);
1708 int i1 = hiByte >> 6;
1709 long l1 = 1L << (hiByte & 077);
1710 int i2 = (curChar & 0xff) >> 6;
1711 long l2 = 1L << (curChar & 077);
1712 do
1713 {
1714 switch(jjstateSet[--i])
1715 {
1716 case 0:
1717 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1718 break;
1719 if (kind > 73)
1720 kind = 73;
1721 jjCheckNAdd(29);
1722 break;
1723 case 11:
1724 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1725 jjstateSet[jjnewStateCnt++] = 12;
1726 break;
1727 case 20:
1728 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1729 jjAddStates(18, 20);
1730 break;
1731 case 29:
1732 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1733 break;
1734 if (kind > 73)
1735 kind = 73;
1736 jjCheckNAdd(29);
1737 break;
1738 case 32:
1739 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1740 break;
1741 if (kind > 6)
1742 kind = 6;
1743 jjAddStates(0, 2);
1744 break;
1745 case 37:
1746 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
1747 kind = 7;
1748 break;
1749 default : break;
1750 }
1751 } while(i != startsAt);
1752 }
1753 if (kind != 0x7fffffff)
1754 {
1755 jjmatchedKind = kind;
1756 jjmatchedPos = curPos;
1757 kind = 0x7fffffff;
1758 }
1759 ++curPos;
1760 if ((i = jjnewStateCnt) == (startsAt = 99 - (jjnewStateCnt = startsAt)))
1761 return curPos;
1762 try { curChar = input_stream.readChar(); }
1763 catch(java.io.IOException e) { return curPos; }
1764 }
1765 }
1766 private int jjMoveStringLiteralDfa0_2()
1767 {
1768 switch(curChar)
1769 {
1770 case 42:
1771 return jjMoveStringLiteralDfa1_2(0x400L);
1772 default :
1773 return 1;
1774 }
1775 }
1776 private int jjMoveStringLiteralDfa1_2(long active0)
1777 {
1778 try { curChar = input_stream.readChar(); }
1779 catch(java.io.IOException e) {
1780 return 1;
1781 }
1782 switch(curChar)
1783 {
1784 case 47:
1785 if ((active0 & 0x400L) != 0L)
1786 return jjStopAtPos(1, 10);
1787 break;
1788 default :
1789 return 2;
1790 }
1791 return 2;
1792 }
1793 private int jjMoveStringLiteralDfa0_1()
1794 {
1795 switch(curChar)
1796 {
1797 case 42:
1798 return jjMoveStringLiteralDfa1_1(0x200L);
1799 default :
1800 return 1;
1801 }
1802 }
1803 private int jjMoveStringLiteralDfa1_1(long active0)
1804 {
1805 try { curChar = input_stream.readChar(); }
1806 catch(java.io.IOException e) {
1807 return 1;
1808 }
1809 switch(curChar)
1810 {
1811 case 47:
1812 if ((active0 & 0x200L) != 0L)
1813 return jjStopAtPos(1, 9);
1814 break;
1815 default :
1816 return 2;
1817 }
1818 return 2;
1819 }
1820 static final int[] jjnextStates = {
1821 32, 33, 35, 40, 41, 42, 43, 44, 45, 54, 55, 56, 61, 62, 63, 9,
1822 31, 38, 20, 21, 23, 11, 13, 69, 73, 77, 80, 91, 2, 3, 4, 9,
1823 7, 8, 9, 20, 21, 25, 23, 46, 49, 9, 47, 48, 49, 9, 52, 53,
1824 9, 59, 60, 9, 66, 67, 9, 71, 72, 42, 75, 76, 42, 78, 79, 42,
1825 82, 83, 84, 85, 88, 89, 90, 93, 94, 95, 97, 98, 85, 2, 3, 5,
1826 6, 7, 8, 14, 15, 17, 22, 24, 26, 40, 41, 43, 44, 47, 48, 50,
1827 51, 52, 53, 54, 55, 57, 58, 59, 60, 61, 62, 64, 65, 66, 67, 75,
1828 76, 78, 79, 86, 87, 88, 89,
1829 };
1830 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1831 {
1832 switch(hiByte)
1833 {
1834 case 0:
1835 return ((jjbitVec2[i2] & l2) != 0L);
1836 default :
1837 if ((jjbitVec0[i1] & l1) != 0L)
1838 return true;
1839 return false;
1840 }
1841 }
1842 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1843 {
1844 switch(hiByte)
1845 {
1846 case 0:
1847 return ((jjbitVec4[i2] & l2) != 0L);
1848 case 2:
1849 return ((jjbitVec5[i2] & l2) != 0L);
1850 case 3:
1851 return ((jjbitVec6[i2] & l2) != 0L);
1852 case 4:
1853 return ((jjbitVec7[i2] & l2) != 0L);
1854 case 5:
1855 return ((jjbitVec8[i2] & l2) != 0L);
1856 case 6:
1857 return ((jjbitVec9[i2] & l2) != 0L);
1858 case 7:
1859 return ((jjbitVec10[i2] & l2) != 0L);
1860 case 9:
1861 return ((jjbitVec11[i2] & l2) != 0L);
1862 case 10:
1863 return ((jjbitVec12[i2] & l2) != 0L);
1864 case 11:
1865 return ((jjbitVec13[i2] & l2) != 0L);
1866 case 12:
1867 return ((jjbitVec14[i2] & l2) != 0L);
1868 case 13:
1869 return ((jjbitVec15[i2] & l2) != 0L);
1870 case 14:
1871 return ((jjbitVec16[i2] & l2) != 0L);
1872 case 15:
1873 return ((jjbitVec17[i2] & l2) != 0L);
1874 case 16:
1875 return ((jjbitVec18[i2] & l2) != 0L);
1876 case 17:
1877 return ((jjbitVec19[i2] & l2) != 0L);
1878 case 18:
1879 return ((jjbitVec20[i2] & l2) != 0L);
1880 case 19:
1881 return ((jjbitVec21[i2] & l2) != 0L);
1882 case 20:
1883 return ((jjbitVec0[i2] & l2) != 0L);
1884 case 22:
1885 return ((jjbitVec22[i2] & l2) != 0L);
1886 case 23:
1887 return ((jjbitVec23[i2] & l2) != 0L);
1888 case 24:
1889 return ((jjbitVec24[i2] & l2) != 0L);
1890 case 30:
1891 return ((jjbitVec25[i2] & l2) != 0L);
1892 case 31:
1893 return ((jjbitVec26[i2] & l2) != 0L);
1894 case 32:
1895 return ((jjbitVec27[i2] & l2) != 0L);
1896 case 33:
1897 return ((jjbitVec28[i2] & l2) != 0L);
1898 case 48:
1899 return ((jjbitVec29[i2] & l2) != 0L);
1900 case 49:
1901 return ((jjbitVec30[i2] & l2) != 0L);
1902 case 77:
1903 return ((jjbitVec31[i2] & l2) != 0L);
1904 case 159:
1905 return ((jjbitVec32[i2] & l2) != 0L);
1906 case 164:
1907 return ((jjbitVec33[i2] & l2) != 0L);
1908 case 215:
1909 return ((jjbitVec34[i2] & l2) != 0L);
1910 case 250:
1911 return ((jjbitVec35[i2] & l2) != 0L);
1912 case 251:
1913 return ((jjbitVec36[i2] & l2) != 0L);
1914 case 253:
1915 return ((jjbitVec37[i2] & l2) != 0L);
1916 case 254:
1917 return ((jjbitVec38[i2] & l2) != 0L);
1918 case 255:
1919 return ((jjbitVec39[i2] & l2) != 0L);
1920 default :
1921 if ((jjbitVec3[i1] & l1) != 0L)
1922 return true;
1923 return false;
1924 }
1925 }
1926 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1927 {
1928 switch(hiByte)
1929 {
1930 case 0:
1931 return ((jjbitVec40[i2] & l2) != 0L);
1932 case 2:
1933 return ((jjbitVec5[i2] & l2) != 0L);
1934 case 3:
1935 return ((jjbitVec41[i2] & l2) != 0L);
1936 case 4:
1937 return ((jjbitVec42[i2] & l2) != 0L);
1938 case 5:
1939 return ((jjbitVec43[i2] & l2) != 0L);
1940 case 6:
1941 return ((jjbitVec44[i2] & l2) != 0L);
1942 case 7:
1943 return ((jjbitVec45[i2] & l2) != 0L);
1944 case 9:
1945 return ((jjbitVec46[i2] & l2) != 0L);
1946 case 10:
1947 return ((jjbitVec47[i2] & l2) != 0L);
1948 case 11:
1949 return ((jjbitVec48[i2] & l2) != 0L);
1950 case 12:
1951 return ((jjbitVec49[i2] & l2) != 0L);
1952 case 13:
1953 return ((jjbitVec50[i2] & l2) != 0L);
1954 case 14:
1955 return ((jjbitVec51[i2] & l2) != 0L);
1956 case 15:
1957 return ((jjbitVec52[i2] & l2) != 0L);
1958 case 16:
1959 return ((jjbitVec53[i2] & l2) != 0L);
1960 case 17:
1961 return ((jjbitVec19[i2] & l2) != 0L);
1962 case 18:
1963 return ((jjbitVec20[i2] & l2) != 0L);
1964 case 19:
1965 return ((jjbitVec54[i2] & l2) != 0L);
1966 case 20:
1967 return ((jjbitVec0[i2] & l2) != 0L);
1968 case 22:
1969 return ((jjbitVec22[i2] & l2) != 0L);
1970 case 23:
1971 return ((jjbitVec55[i2] & l2) != 0L);
1972 case 24:
1973 return ((jjbitVec56[i2] & l2) != 0L);
1974 case 30:
1975 return ((jjbitVec25[i2] & l2) != 0L);
1976 case 31:
1977 return ((jjbitVec26[i2] & l2) != 0L);
1978 case 32:
1979 return ((jjbitVec57[i2] & l2) != 0L);
1980 case 33:
1981 return ((jjbitVec28[i2] & l2) != 0L);
1982 case 48:
1983 return ((jjbitVec58[i2] & l2) != 0L);
1984 case 49:
1985 return ((jjbitVec30[i2] & l2) != 0L);
1986 case 77:
1987 return ((jjbitVec31[i2] & l2) != 0L);
1988 case 159:
1989 return ((jjbitVec32[i2] & l2) != 0L);
1990 case 164:
1991 return ((jjbitVec33[i2] & l2) != 0L);
1992 case 215:
1993 return ((jjbitVec34[i2] & l2) != 0L);
1994 case 250:
1995 return ((jjbitVec35[i2] & l2) != 0L);
1996 case 251:
1997 return ((jjbitVec59[i2] & l2) != 0L);
1998 case 253:
1999 return ((jjbitVec37[i2] & l2) != 0L);
2000 case 254:
2001 return ((jjbitVec60[i2] & l2) != 0L);
2002 case 255:
2003 return ((jjbitVec61[i2] & l2) != 0L);
2004 default :
2005 if ((jjbitVec3[i1] & l1) != 0L)
2006 return true;
2007 return false;
2008 }
2009 }
2010
2011
2012 public static final String[] jjstrLiteralImages = {
2013 "", null, null, null, null, null, null, null, null, null, null, null,
2014 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145",
2015 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163",
2016 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
2017 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
2018 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154",
2019 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146",
2020 "\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",
2021 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
2022 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
2023 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
2024 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162",
2025 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
2026 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164",
2027 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
2028 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null, null, null, null, null, null,
2029 null, null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135",
2030 "\73", "\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75",
2031 "\74\75", "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55",
2032 "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75",
2033 "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75",
2034 "\76\76\76\75", "\56\56\56", "\55\76", "\72\72", "\76\76\76", "\76\76", "\76", "\32",
2035 "\176\133\135", };
2036
2037
2038 public static final String[] lexStateNames = {
2039 "DEFAULT",
2040 "IN_FORMAL_COMMENT",
2041 "IN_MULTI_LINE_COMMENT",
2042 };
2043
2044
2045 public static final int[] jjnewLexState = {
2046 -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,
2047 -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,
2048 -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,
2049 -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,
2050 -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,
2051 -1, -1, -1,
2052 };
2053 static final long[] jjtoToken = {
2054 0xfffffffffffff001L, 0xfffffffffffff3b0L, 0x0L,
2055 };
2056 static final long[] jjtoSkip = {
2057 0x67eL, 0x0L, 0x0L,
2058 };
2059 static final long[] jjtoSpecial = {
2060 0x67eL, 0x0L, 0x0L,
2061 };
2062 static final long[] jjtoMore = {
2063 0x980L, 0x0L, 0x0L,
2064 };
2065 protected CharStream input_stream;
2066 private final int[] jjrounds = new int[99];
2067 private final int[] jjstateSet = new int[198];
2068 private final StringBuilder jjimage = new StringBuilder();
2069 private StringBuilder image = jjimage;
2070 private int jjimageLen;
2071 private int lengthOfMatch;
2072 protected char curChar;
2073
2074 public JavaParserTokenManager(CharStream stream){
2075 input_stream = stream;
2076 }
2077
2078
2079 public JavaParserTokenManager(CharStream stream, int lexState){
2080 this(stream);
2081 SwitchTo(lexState);
2082 }
2083
2084
2085 public void ReInit(CharStream stream)
2086 {
2087 jjmatchedPos = jjnewStateCnt = 0;
2088 curLexState = defaultLexState;
2089 input_stream = stream;
2090 ReInitRounds();
2091 }
2092 private void ReInitRounds()
2093 {
2094 int i;
2095 jjround = 0x80000001;
2096 for (i = 99; i-- > 0;)
2097 jjrounds[i] = 0x80000000;
2098 }
2099
2100
2101 public void ReInit(CharStream stream, int lexState)
2102 {
2103 ReInit(stream);
2104 SwitchTo(lexState);
2105 }
2106
2107
2108 public void SwitchTo(int lexState)
2109 {
2110 if (lexState >= 3 || lexState < 0)
2111 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2112 else
2113 curLexState = lexState;
2114 }
2115
2116 protected Token jjFillToken()
2117 {
2118 final Token t;
2119 final String curTokenImage;
2120 final int beginLine;
2121 final int endLine;
2122 final int beginColumn;
2123 final int endColumn;
2124 String im = jjstrLiteralImages[jjmatchedKind];
2125 curTokenImage = (im == null) ? input_stream.GetImage() : im;
2126 beginLine = input_stream.getBeginLine();
2127 beginColumn = input_stream.getBeginColumn();
2128 endLine = input_stream.getEndLine();
2129 endColumn = input_stream.getEndColumn();
2130 t = Token.newToken(jjmatchedKind, curTokenImage);
2131
2132 t.beginLine = beginLine;
2133 t.endLine = endLine;
2134 t.beginColumn = beginColumn;
2135 t.endColumn = endColumn;
2136
2137 return t;
2138 }
2139
2140 int curLexState = 0;
2141 int defaultLexState = 0;
2142 int jjnewStateCnt;
2143 int jjround;
2144 int jjmatchedPos;
2145 int jjmatchedKind;
2146
2147
2148 public Token getNextToken()
2149 {
2150 Token specialToken = null;
2151 Token matchedToken;
2152 int curPos = 0;
2153
2154 EOFLoop :
2155 for (;;)
2156 {
2157 try
2158 {
2159 curChar = input_stream.BeginToken();
2160 }
2161 catch(java.io.IOException e)
2162 {
2163 jjmatchedKind = 0;
2164 matchedToken = jjFillToken();
2165 matchedToken.specialToken = specialToken;
2166 return matchedToken;
2167 }
2168 image = jjimage;
2169 image.setLength(0);
2170 jjimageLen = 0;
2171
2172 for (;;)
2173 {
2174 switch(curLexState)
2175 {
2176 case 0:
2177 jjmatchedKind = 0x7fffffff;
2178 jjmatchedPos = 0;
2179 curPos = jjMoveStringLiteralDfa0_0();
2180 break;
2181 case 1:
2182 jjmatchedKind = 0x7fffffff;
2183 jjmatchedPos = 0;
2184 curPos = jjMoveStringLiteralDfa0_1();
2185 if (jjmatchedPos == 0 && jjmatchedKind > 11)
2186 {
2187 jjmatchedKind = 11;
2188 }
2189 break;
2190 case 2:
2191 jjmatchedKind = 0x7fffffff;
2192 jjmatchedPos = 0;
2193 curPos = jjMoveStringLiteralDfa0_2();
2194 if (jjmatchedPos == 0 && jjmatchedKind > 11)
2195 {
2196 jjmatchedKind = 11;
2197 }
2198 break;
2199 }
2200 if (jjmatchedKind != 0x7fffffff)
2201 {
2202 if (jjmatchedPos + 1 < curPos)
2203 input_stream.backup(curPos - jjmatchedPos - 1);
2204 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2205 {
2206 matchedToken = jjFillToken();
2207 matchedToken.specialToken = specialToken;
2208 TokenLexicalActions(matchedToken);
2209 if (jjnewLexState[jjmatchedKind] != -1)
2210 curLexState = jjnewLexState[jjmatchedKind];
2211 return matchedToken;
2212 }
2213 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2214 {
2215 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2216 {
2217 matchedToken = jjFillToken();
2218 if (specialToken == null)
2219 specialToken = matchedToken;
2220 else
2221 {
2222 matchedToken.specialToken = specialToken;
2223 specialToken = (specialToken.next = matchedToken);
2224 }
2225 SkipLexicalActions(matchedToken);
2226 }
2227 else
2228 SkipLexicalActions(null);
2229 if (jjnewLexState[jjmatchedKind] != -1)
2230 curLexState = jjnewLexState[jjmatchedKind];
2231 continue EOFLoop;
2232 }
2233 MoreLexicalActions();
2234 if (jjnewLexState[jjmatchedKind] != -1)
2235 curLexState = jjnewLexState[jjmatchedKind];
2236 curPos = 0;
2237 jjmatchedKind = 0x7fffffff;
2238 try {
2239 curChar = input_stream.readChar();
2240 continue;
2241 }
2242 catch (java.io.IOException e1) { }
2243 }
2244 int error_line = input_stream.getEndLine();
2245 int error_column = input_stream.getEndColumn();
2246 String error_after = null;
2247 boolean EOFSeen = false;
2248 try { input_stream.readChar(); input_stream.backup(1); }
2249 catch (java.io.IOException e1) {
2250 EOFSeen = true;
2251 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2252 if (curChar == '\n' || curChar == '\r') {
2253 error_line++;
2254 error_column = 0;
2255 }
2256 else
2257 error_column++;
2258 }
2259 if (!EOFSeen) {
2260 input_stream.backup(1);
2261 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2262 }
2263 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2264 }
2265 }
2266 }
2267
2268 void SkipLexicalActions(Token matchedToken)
2269 {
2270 switch(jjmatchedKind)
2271 {
2272 case 6 :
2273 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2274 int startOfNOPMD = matchedToken.image.indexOf(suppressMarker);
2275 if (startOfNOPMD != -1) {
2276 suppressMap.put(matchedToken.beginLine, matchedToken.image.substring(startOfNOPMD + suppressMarker.length()));
2277 }
2278 comments.add(new SingleLineComment(matchedToken));
2279 break;
2280 case 9 :
2281 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2282 comments.add(new FormalComment(matchedToken));
2283 break;
2284 case 10 :
2285 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2286 comments.add(new MultiLineComment(matchedToken));
2287 break;
2288 default :
2289 break;
2290 }
2291 }
2292 void MoreLexicalActions()
2293 {
2294 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2295 switch(jjmatchedKind)
2296 {
2297 case 7 :
2298 image.append(input_stream.GetSuffix(jjimageLen));
2299 jjimageLen = 0;
2300 input_stream.backup(1);
2301 break;
2302 default :
2303 break;
2304 }
2305 }
2306 void TokenLexicalActions(Token matchedToken)
2307 {
2308 switch(jjmatchedKind)
2309 {
2310 case 123 :
2311 image.append(jjstrLiteralImages[123]);
2312 lengthOfMatch = jjstrLiteralImages[123].length();
2313 matchedToken.kind = GT;
2314 ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT;
2315 input_stream.backup(2);
2316 matchedToken.image = ">";
2317 break;
2318 case 124 :
2319 image.append(jjstrLiteralImages[124]);
2320 lengthOfMatch = jjstrLiteralImages[124].length();
2321 matchedToken.kind = GT;
2322 ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT;
2323 input_stream.backup(1);
2324 matchedToken.image = ">";
2325 break;
2326 default :
2327 break;
2328 }
2329 }
2330 private void jjCheckNAdd(int state)
2331 {
2332 if (jjrounds[state] != jjround)
2333 {
2334 jjstateSet[jjnewStateCnt++] = state;
2335 jjrounds[state] = jjround;
2336 }
2337 }
2338 private void jjAddStates(int start, int end)
2339 {
2340 do {
2341 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2342 } while (start++ != end);
2343 }
2344 private void jjCheckNAddTwoStates(int state1, int state2)
2345 {
2346 jjCheckNAdd(state1);
2347 jjCheckNAdd(state2);
2348 }
2349
2350 private void jjCheckNAddStates(int start, int end)
2351 {
2352 do {
2353 jjCheckNAdd(jjnextStates[start]);
2354 } while (start++ != end);
2355 }
2356
2357 }