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