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