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