1
2 package xjavadoc;
3 import java.lang.reflect.Modifier;
4 import java.util.*;
5 import java.io.InputStream;
6 import java.io.ByteArrayInputStream;
7
8 public class NodeParserTokenManager implements NodeParserConstants
9 {
10 public java.io.PrintStream debugStream = System.out;
11 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
12 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
13 {
14 switch (pos)
15 {
16 case 0:
17 if ((active0 & 0x140L) != 0L || (active1 & 0x4008000000000L) != 0L)
18 return 2;
19 if ((active1 & 0x100000L) != 0L)
20 return 8;
21 if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L)
22 {
23 jjmatchedKind = 73;
24 return 32;
25 }
26 return -1;
27 case 1:
28 if ((active0 & 0x100L) != 0L)
29 return 0;
30 if ((active0 & 0xfffffffbfcffe000L) != 0L || (active1 & 0x1L) != 0L)
31 {
32 if (jjmatchedPos != 1)
33 {
34 jjmatchedKind = 73;
35 jjmatchedPos = 1;
36 }
37 return 32;
38 }
39 if ((active0 & 0x403000000L) != 0L)
40 return 32;
41 return -1;
42 case 2:
43 if ((active0 & 0xf7fffb3afeffe000L) != 0L || (active1 & 0x1L) != 0L)
44 {
45 if (jjmatchedPos != 2)
46 {
47 jjmatchedKind = 73;
48 jjmatchedPos = 2;
49 }
50 return 32;
51 }
52 if ((active0 & 0x80004c100000000L) != 0L)
53 return 32;
54 return -1;
55 case 3:
56 if ((active0 & 0xe3bff2b8faf4e000L) != 0L || (active1 & 0x1L) != 0L)
57 {
58 jjmatchedKind = 73;
59 jjmatchedPos = 3;
60 return 32;
61 }
62 if ((active0 & 0x14400902040b0000L) != 0L)
63 return 32;
64 return -1;
65 case 4:
66 if ((active0 & 0xa235f2b80ac06000L) != 0L || (active1 & 0x1L) != 0L)
67 {
68 if (jjmatchedPos != 4)
69 {
70 jjmatchedKind = 73;
71 jjmatchedPos = 4;
72 }
73 return 32;
74 }
75 if ((active0 & 0x418a0000f0348000L) != 0L)
76 return 32;
77 return -1;
78 case 5:
79 if ((active0 & 0xa22070a848c06000L) != 0L)
80 {
81 jjmatchedKind = 73;
82 jjmatchedPos = 5;
83 return 32;
84 }
85 if ((active0 & 0x115821002000000L) != 0L || (active1 & 0x1L) != 0L)
86 return 32;
87 return -1;
88 case 6:
89 if ((active0 & 0xa22040a800402000L) != 0L)
90 {
91 jjmatchedKind = 73;
92 jjmatchedPos = 6;
93 return 32;
94 }
95 if ((active0 & 0x300048804000L) != 0L)
96 return 32;
97 return -1;
98 case 7:
99 if ((active0 & 0x22040a800000000L) != 0L)
100 {
101 jjmatchedKind = 73;
102 jjmatchedPos = 7;
103 return 32;
104 }
105 if ((active0 & 0xa000000000402000L) != 0L)
106 return 32;
107 return -1;
108 case 8:
109 if ((active0 & 0x20002800000000L) != 0L)
110 {
111 jjmatchedKind = 73;
112 jjmatchedPos = 8;
113 return 32;
114 }
115 if ((active0 & 0x200408000000000L) != 0L)
116 return 32;
117 return -1;
118 case 9:
119 if ((active0 & 0x20000000000000L) != 0L)
120 {
121 jjmatchedKind = 73;
122 jjmatchedPos = 9;
123 return 32;
124 }
125 if ((active0 & 0x2800000000L) != 0L)
126 return 32;
127 return -1;
128 case 10:
129 if ((active0 & 0x20000000000000L) != 0L)
130 {
131 jjmatchedKind = 73;
132 jjmatchedPos = 10;
133 return 32;
134 }
135 return -1;
136 default :
137 return -1;
138 }
139 }
140 private final int jjStartNfa_0(int pos, long active0, long active1)
141 {
142 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
143 }
144 private final int jjStopAtPos(int pos, int kind)
145 {
146 jjmatchedKind = kind;
147 jjmatchedPos = pos;
148 return pos + 1;
149 }
150 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
151 {
152 jjmatchedKind = kind;
153 jjmatchedPos = pos;
154 try { curChar = input_stream.readChar(); }
155 catch(java.io.IOException e) { return pos + 1; }
156 return jjMoveNfa_0(state, pos + 1);
157 }
158 private final int jjMoveStringLiteralDfa0_0()
159 {
160 switch(curChar)
161 {
162 case 9:
163 return jjStopAtPos(0, 2);
164 case 10:
165 return jjStopAtPos(0, 3);
166 case 12:
167 return jjStopAtPos(0, 5);
168 case 13:
169 return jjStopAtPos(0, 4);
170 case 32:
171 return jjStopAtPos(0, 1);
172 case 33:
173 jjmatchedKind = 88;
174 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
175 case 37:
176 jjmatchedKind = 107;
177 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
178 case 38:
179 jjmatchedKind = 104;
180 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L);
181 case 40:
182 return jjStopAtPos(0, 76);
183 case 41:
184 return jjStopAtPos(0, 77);
185 case 42:
186 jjmatchedKind = 102;
187 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
188 case 43:
189 jjmatchedKind = 100;
190 return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L);
191 case 44:
192 return jjStopAtPos(0, 83);
193 case 45:
194 jjmatchedKind = 101;
195 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000800000000L);
196 case 46:
197 return jjStartNfaWithStates_0(0, 84, 8);
198 case 47:
199 jjmatchedKind = 103;
200 return jjMoveStringLiteralDfa1_0(0x140L, 0x4000000000000L);
201 case 58:
202 return jjStopAtPos(0, 91);
203 case 59:
204 return jjStopAtPos(0, 82);
205 case 60:
206 jjmatchedKind = 87;
207 return jjMoveStringLiteralDfa1_0(0x0L, 0x80100020000000L);
208 case 61:
209 jjmatchedKind = 85;
210 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
211 case 62:
212 jjmatchedKind = 86;
213 return jjMoveStringLiteralDfa1_0(0x0L, 0x300600040000000L);
214 case 63:
215 return jjStopAtPos(0, 90);
216 case 91:
217 return jjStopAtPos(0, 80);
218 case 93:
219 return jjStopAtPos(0, 81);
220 case 94:
221 jjmatchedKind = 106;
222 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
223 case 97:
224 return jjMoveStringLiteralDfa1_0(0x2000L, 0x1L);
225 case 98:
226 return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L);
227 case 99:
228 return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L);
229 case 100:
230 return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L);
231 case 101:
232 return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L);
233 case 102:
234 return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L);
235 case 103:
236 return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L);
237 case 105:
238 return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L);
239 case 108:
240 return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L);
241 case 110:
242 return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L);
243 case 112:
244 return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L);
245 case 114:
246 return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
247 case 115:
248 return jjMoveStringLiteralDfa1_0(0x803e000000000000L, 0x0L);
249 case 116:
250 return jjMoveStringLiteralDfa1_0(0xfc0000000000000L, 0x0L);
251 case 118:
252 return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L);
253 case 119:
254 return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L);
255 case 123:
256 return jjStopAtPos(0, 78);
257 case 124:
258 jjmatchedKind = 105;
259 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000100000000L);
260 case 125:
261 return jjStopAtPos(0, 79);
262 case 126:
263 return jjStopAtPos(0, 89);
264 default :
265 return jjMoveNfa_0(3, 0);
266 }
267 }
268 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
269 {
270 try { curChar = input_stream.readChar(); }
271 catch(java.io.IOException e) {
272 jjStopStringLiteralDfa_0(0, active0, active1);
273 return 1;
274 }
275 switch(curChar)
276 {
277 case 38:
278 if ((active1 & 0x200000000L) != 0L)
279 return jjStopAtPos(1, 97);
280 break;
281 case 42:
282 if ((active0 & 0x100L) != 0L)
283 return jjStartNfaWithStates_0(1, 8, 0);
284 break;
285 case 43:
286 if ((active1 & 0x400000000L) != 0L)
287 return jjStopAtPos(1, 98);
288 break;
289 case 45:
290 if ((active1 & 0x800000000L) != 0L)
291 return jjStopAtPos(1, 99);
292 break;
293 case 47:
294 if ((active0 & 0x40L) != 0L)
295 return jjStopAtPos(1, 6);
296 break;
297 case 60:
298 if ((active1 & 0x100000000000L) != 0L)
299 {
300 jjmatchedKind = 108;
301 jjmatchedPos = 1;
302 }
303 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000000L);
304 case 61:
305 if ((active1 & 0x10000000L) != 0L)
306 return jjStopAtPos(1, 92);
307 else if ((active1 & 0x20000000L) != 0L)
308 return jjStopAtPos(1, 93);
309 else if ((active1 & 0x40000000L) != 0L)
310 return jjStopAtPos(1, 94);
311 else if ((active1 & 0x80000000L) != 0L)
312 return jjStopAtPos(1, 95);
313 else if ((active1 & 0x800000000000L) != 0L)
314 return jjStopAtPos(1, 111);
315 else if ((active1 & 0x1000000000000L) != 0L)
316 return jjStopAtPos(1, 112);
317 else if ((active1 & 0x2000000000000L) != 0L)
318 return jjStopAtPos(1, 113);
319 else if ((active1 & 0x4000000000000L) != 0L)
320 return jjStopAtPos(1, 114);
321 else if ((active1 & 0x8000000000000L) != 0L)
322 return jjStopAtPos(1, 115);
323 else if ((active1 & 0x10000000000000L) != 0L)
324 return jjStopAtPos(1, 116);
325 else if ((active1 & 0x20000000000000L) != 0L)
326 return jjStopAtPos(1, 117);
327 else if ((active1 & 0x40000000000000L) != 0L)
328 return jjStopAtPos(1, 118);
329 break;
330 case 62:
331 if ((active1 & 0x200000000000L) != 0L)
332 {
333 jjmatchedKind = 109;
334 jjmatchedPos = 1;
335 }
336 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x300400000000000L);
337 case 97:
338 return jjMoveStringLiteralDfa2_0(active0, 0x120010060000L, active1, 0L);
339 case 98:
340 return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
341 case 101:
342 return jjMoveStringLiteralDfa2_0(active0, 0x1040000800000L, active1, 0L);
343 case 102:
344 if ((active0 & 0x400000000L) != 0L)
345 return jjStartNfaWithStates_0(1, 34, 32);
346 break;
347 case 104:
348 return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000L, active1, 0L);
349 case 105:
350 return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0L);
351 case 108:
352 return jjMoveStringLiteralDfa2_0(active0, 0x84100000L, active1, 0L);
353 case 109:
354 return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L);
355 case 110:
356 return jjMoveStringLiteralDfa2_0(active0, 0xe000000000L, active1, 0L);
357 case 111:
358 if ((active0 & 0x1000000L) != 0L)
359 {
360 jjmatchedKind = 24;
361 jjmatchedPos = 1;
362 }
363 return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000L, active1, 0L);
364 case 114:
365 return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000L, active1, 0L);
366 case 115:
367 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1L);
368 case 116:
369 return jjMoveStringLiteralDfa2_0(active0, 0x8004000000000000L, active1, 0L);
370 case 117:
371 return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000L, active1, 0L);
372 case 119:
373 return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 0L);
374 case 120:
375 return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0L);
376 case 121:
377 return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000L, active1, 0L);
378 case 124:
379 if ((active1 & 0x100000000L) != 0L)
380 return jjStopAtPos(1, 96);
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 61:
399 if ((active1 & 0x80000000000000L) != 0L)
400 return jjStopAtPos(2, 119);
401 else if ((active1 & 0x100000000000000L) != 0L)
402 return jjStopAtPos(2, 120);
403 break;
404 case 62:
405 if ((active1 & 0x400000000000L) != 0L)
406 {
407 jjmatchedKind = 110;
408 jjmatchedPos = 2;
409 }
410 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000000000000L);
411 case 97:
412 return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000L, active1, 0L);
413 case 98:
414 return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0L);
415 case 99:
416 return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L);
417 case 101:
418 return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L);
419 case 102:
420 return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L);
421 case 105:
422 return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000L, active1, 0L);
423 case 108:
424 return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000L, active1, 0L);
425 case 110:
426 return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000L, active1, 0L);
427 case 111:
428 return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000L, active1, 0L);
429 case 112:
430 return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000L, active1, 0L);
431 case 114:
432 if ((active0 & 0x100000000L) != 0L)
433 return jjStartNfaWithStates_0(2, 32, 32);
434 return jjMoveStringLiteralDfa3_0(active0, 0x8180000000000000L, active1, 0L);
435 case 115:
436 return jjMoveStringLiteralDfa3_0(active0, 0x2004022000L, active1, 0x1L);
437 case 116:
438 if ((active0 & 0x4000000000L) != 0L)
439 {
440 jjmatchedKind = 38;
441 jjmatchedPos = 2;
442 }
443 return jjMoveStringLiteralDfa3_0(active0, 0x1028208050000L, active1, 0L);
444 case 117:
445 return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000L, active1, 0L);
446 case 119:
447 if ((active0 & 0x40000000000L) != 0L)
448 return jjStartNfaWithStates_0(2, 42, 32);
449 break;
450 case 121:
451 if ((active0 & 0x800000000000000L) != 0L)
452 return jjStartNfaWithStates_0(2, 59, 32);
453 break;
454 default :
455 break;
456 }
457 return jjStartNfa_0(1, active0, active1);
458 }
459 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
460 {
461 if (((active0 &= old0) | (active1 &= old1)) == 0L)
462 return jjStartNfa_0(1, old0, old1);
463 try { curChar = input_stream.readChar(); }
464 catch(java.io.IOException e) {
465 jjStopStringLiteralDfa_0(2, active0, active1);
466 return 3;
467 }
468 switch(curChar)
469 {
470 case 61:
471 if ((active1 & 0x200000000000000L) != 0L)
472 return jjStopAtPos(3, 121);
473 break;
474 case 97:
475 return jjMoveStringLiteralDfa4_0(active0, 0x20000000e0808000L, active1, 0L);
476 case 98:
477 return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L);
478 case 99:
479 return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000L, active1, 0L);
480 case 100:
481 if ((active0 & 0x1000000000000000L) != 0L)
482 return jjStartNfaWithStates_0(3, 60, 32);
483 break;
484 case 101:
485 if ((active0 & 0x10000L) != 0L)
486 return jjStartNfaWithStates_0(3, 16, 32);
487 else if ((active0 & 0x20000L) != 0L)
488 return jjStartNfaWithStates_0(3, 17, 32);
489 else if ((active0 & 0x4000000L) != 0L)
490 return jjStartNfaWithStates_0(3, 26, 32);
491 else if ((active0 & 0x400000000000000L) != 0L)
492 return jjStartNfaWithStates_0(3, 58, 32);
493 return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000L, active1, 0x1L);
494 case 103:
495 if ((active0 & 0x10000000000L) != 0L)
496 return jjStartNfaWithStates_0(3, 40, 32);
497 break;
498 case 105:
499 return jjMoveStringLiteralDfa4_0(active0, 0x8000020000000000L, active1, 0L);
500 case 107:
501 return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
502 case 108:
503 if ((active0 & 0x80000000000L) != 0L)
504 return jjStartNfaWithStates_0(3, 43, 32);
505 return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000L, active1, 0L);
506 case 110:
507 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L, active1, 0L);
508 case 111:
509 if ((active0 & 0x200000000L) != 0L)
510 return jjStartNfaWithStates_0(3, 33, 32);
511 return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000L, active1, 0L);
512 case 114:
513 if ((active0 & 0x80000L) != 0L)
514 return jjStartNfaWithStates_0(3, 19, 32);
515 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
516 case 115:
517 if ((active0 & 0x40000000000000L) != 0L)
518 return jjStartNfaWithStates_0(3, 54, 32);
519 return jjMoveStringLiteralDfa4_0(active0, 0x10300000L, active1, 0L);
520 case 116:
521 return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000L, active1, 0L);
522 case 117:
523 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
524 case 118:
525 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
526 default :
527 break;
528 }
529 return jjStartNfa_0(2, active0, active1);
530 }
531 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
532 {
533 if (((active0 &= old0) | (active1 &= old1)) == 0L)
534 return jjStartNfa_0(2, old0, old1);
535 try { curChar = input_stream.readChar(); }
536 catch(java.io.IOException e) {
537 jjStopStringLiteralDfa_0(3, active0, active1);
538 return 4;
539 }
540 switch(curChar)
541 {
542 case 97:
543 return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0L);
544 case 99:
545 return jjMoveStringLiteralDfa5_0(active0, 0x8010000000000000L, active1, 0L);
546 case 101:
547 if ((active0 & 0x10000000L) != 0L)
548 return jjStartNfaWithStates_0(4, 28, 32);
549 else if ((active0 & 0x4000000000000000L) != 0L)
550 return jjStartNfaWithStates_0(4, 62, 32);
551 return jjMoveStringLiteralDfa5_0(active0, 0x400800004000L, active1, 0L);
552 case 104:
553 if ((active0 & 0x40000L) != 0L)
554 return jjStartNfaWithStates_0(4, 18, 32);
555 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0L);
556 case 105:
557 return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000L, active1, 0L);
558 case 107:
559 if ((active0 & 0x8000L) != 0L)
560 return jjStartNfaWithStates_0(4, 15, 32);
561 break;
562 case 108:
563 if ((active0 & 0x20000000L) != 0L)
564 {
565 jjmatchedKind = 29;
566 jjmatchedPos = 4;
567 }
568 return jjMoveStringLiteralDfa5_0(active0, 0x42000000L, active1, 0L);
569 case 110:
570 return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L);
571 case 114:
572 if ((active0 & 0x8000000000000L) != 0L)
573 return jjStartNfaWithStates_0(4, 51, 32);
574 return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000L, active1, 0x1L);
575 case 115:
576 if ((active0 & 0x100000L) != 0L)
577 return jjStartNfaWithStates_0(4, 20, 32);
578 return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L);
579 case 116:
580 if ((active0 & 0x200000L) != 0L)
581 return jjStartNfaWithStates_0(4, 21, 32);
582 else if ((active0 & 0x80000000L) != 0L)
583 return jjStartNfaWithStates_0(4, 31, 32);
584 else if ((active0 & 0x2000000000000L) != 0L)
585 return jjStartNfaWithStates_0(4, 49, 32);
586 return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0L);
587 case 117:
588 return jjMoveStringLiteralDfa5_0(active0, 0x800000L, active1, 0L);
589 case 118:
590 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0L);
591 case 119:
592 if ((active0 & 0x80000000000000L) != 0L)
593 {
594 jjmatchedKind = 55;
595 jjmatchedPos = 4;
596 }
597 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L);
598 default :
599 break;
600 }
601 return jjStartNfa_0(3, active0, active1);
602 }
603 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
604 {
605 if (((active0 &= old0) | (active1 &= old1)) == 0L)
606 return jjStartNfa_0(3, old0, old1);
607 try { curChar = input_stream.readChar(); }
608 catch(java.io.IOException e) {
609 jjStopStringLiteralDfa_0(4, active0, active1);
610 return 5;
611 }
612 switch(curChar)
613 {
614 case 97:
615 return jjMoveStringLiteralDfa6_0(active0, 0x6000L, active1, 0L);
616 case 99:
617 if ((active0 & 0x800000000000L) != 0L)
618 return jjStartNfaWithStates_0(5, 47, 32);
619 else if ((active0 & 0x4000000000000L) != 0L)
620 return jjStartNfaWithStates_0(5, 50, 32);
621 return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
622 case 100:
623 return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0L);
624 case 101:
625 if ((active0 & 0x2000000L) != 0L)
626 return jjStartNfaWithStates_0(5, 25, 32);
627 else if ((active0 & 0x20000000000L) != 0L)
628 return jjStartNfaWithStates_0(5, 41, 32);
629 break;
630 case 102:
631 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
632 case 103:
633 return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0L);
634 case 104:
635 if ((active0 & 0x10000000000000L) != 0L)
636 return jjStartNfaWithStates_0(5, 52, 32);
637 break;
638 case 105:
639 return jjMoveStringLiteralDfa6_0(active0, 0x2200000000000000L, active1, 0L);
640 case 108:
641 return jjMoveStringLiteralDfa6_0(active0, 0x40800000L, active1, 0L);
642 case 109:
643 return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0L);
644 case 110:
645 if ((active0 & 0x1000000000000L) != 0L)
646 return jjStartNfaWithStates_0(5, 48, 32);
647 return jjMoveStringLiteralDfa6_0(active0, 0x2000400000L, active1, 0L);
648 case 114:
649 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L);
650 case 115:
651 if ((active0 & 0x100000000000000L) != 0L)
652 return jjStartNfaWithStates_0(5, 56, 32);
653 break;
654 case 116:
655 if ((active0 & 0x1000000000L) != 0L)
656 return jjStartNfaWithStates_0(5, 36, 32);
657 else if ((active1 & 0x1L) != 0L)
658 return jjStartNfaWithStates_0(5, 64, 32);
659 return jjMoveStringLiteralDfa6_0(active0, 0x8000200000000000L, active1, 0L);
660 default :
661 break;
662 }
663 return jjStartNfa_0(4, active0, active1);
664 }
665 private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
666 {
667 if (((active0 &= old0) | (active1 &= old1)) == 0L)
668 return jjStartNfa_0(4, old0, old1);
669 try { curChar = input_stream.readChar(); }
670 catch(java.io.IOException e) {
671 jjStopStringLiteralDfa_0(5, active0, 0L);
672 return 6;
673 }
674 switch(curChar)
675 {
676 case 97:
677 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L);
678 case 99:
679 return jjMoveStringLiteralDfa7_0(active0, 0x2000002000L);
680 case 101:
681 if ((active0 & 0x100000000000L) != 0L)
682 return jjStartNfaWithStates_0(6, 44, 32);
683 else if ((active0 & 0x200000000000L) != 0L)
684 return jjStartNfaWithStates_0(6, 45, 32);
685 return jjMoveStringLiteralDfa7_0(active0, 0x200000800000000L);
686 case 102:
687 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L);
688 case 108:
689 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L);
690 case 110:
691 if ((active0 & 0x4000L) != 0L)
692 return jjStartNfaWithStates_0(6, 14, 32);
693 break;
694 case 111:
695 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L);
696 case 115:
697 if ((active0 & 0x8000000L) != 0L)
698 return jjStartNfaWithStates_0(6, 27, 32);
699 break;
700 case 116:
701 if ((active0 & 0x800000L) != 0L)
702 return jjStartNfaWithStates_0(6, 23, 32);
703 return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L);
704 case 117:
705 return jjMoveStringLiteralDfa7_0(active0, 0x400000L);
706 case 121:
707 if ((active0 & 0x40000000L) != 0L)
708 return jjStartNfaWithStates_0(6, 30, 32);
709 break;
710 default :
711 break;
712 }
713 return jjStartNfa_0(5, active0, 0L);
714 }
715 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
716 {
717 if (((active0 &= old0)) == 0L)
718 return jjStartNfa_0(5, old0, 0L);
719 try { curChar = input_stream.readChar(); }
720 catch(java.io.IOException e) {
721 jjStopStringLiteralDfa_0(6, active0, 0L);
722 return 7;
723 }
724 switch(curChar)
725 {
726 case 99:
727 return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L);
728 case 101:
729 if ((active0 & 0x400000L) != 0L)
730 return jjStartNfaWithStates_0(7, 22, 32);
731 else if ((active0 & 0x2000000000000000L) != 0L)
732 return jjStartNfaWithStates_0(7, 61, 32);
733 return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L);
734 case 110:
735 return jjMoveStringLiteralDfa8_0(active0, 0x220000800000000L);
736 case 112:
737 if ((active0 & 0x8000000000000000L) != 0L)
738 return jjStartNfaWithStates_0(7, 63, 32);
739 break;
740 case 116:
741 if ((active0 & 0x2000L) != 0L)
742 return jjStartNfaWithStates_0(7, 13, 32);
743 break;
744 default :
745 break;
746 }
747 return jjStartNfa_0(6, active0, 0L);
748 }
749 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
750 {
751 if (((active0 &= old0)) == 0L)
752 return jjStartNfa_0(6, old0, 0L);
753 try { curChar = input_stream.readChar(); }
754 catch(java.io.IOException e) {
755 jjStopStringLiteralDfa_0(7, active0, 0L);
756 return 8;
757 }
758 switch(curChar)
759 {
760 case 100:
761 if ((active0 & 0x400000000000L) != 0L)
762 return jjStartNfaWithStates_0(8, 46, 32);
763 break;
764 case 101:
765 if ((active0 & 0x8000000000L) != 0L)
766 return jjStartNfaWithStates_0(8, 39, 32);
767 break;
768 case 105:
769 return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L);
770 case 111:
771 return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L);
772 case 116:
773 if ((active0 & 0x200000000000000L) != 0L)
774 return jjStartNfaWithStates_0(8, 57, 32);
775 return jjMoveStringLiteralDfa9_0(active0, 0x800000000L);
776 default :
777 break;
778 }
779 return jjStartNfa_0(7, active0, 0L);
780 }
781 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
782 {
783 if (((active0 &= old0)) == 0L)
784 return jjStartNfa_0(7, old0, 0L);
785 try { curChar = input_stream.readChar(); }
786 catch(java.io.IOException e) {
787 jjStopStringLiteralDfa_0(8, active0, 0L);
788 return 9;
789 }
790 switch(curChar)
791 {
792 case 102:
793 if ((active0 & 0x2000000000L) != 0L)
794 return jjStartNfaWithStates_0(9, 37, 32);
795 break;
796 case 115:
797 if ((active0 & 0x800000000L) != 0L)
798 return jjStartNfaWithStates_0(9, 35, 32);
799 break;
800 case 122:
801 return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L);
802 default :
803 break;
804 }
805 return jjStartNfa_0(8, active0, 0L);
806 }
807 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
808 {
809 if (((active0 &= old0)) == 0L)
810 return jjStartNfa_0(8, old0, 0L);
811 try { curChar = input_stream.readChar(); }
812 catch(java.io.IOException e) {
813 jjStopStringLiteralDfa_0(9, active0, 0L);
814 return 10;
815 }
816 switch(curChar)
817 {
818 case 101:
819 return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L);
820 default :
821 break;
822 }
823 return jjStartNfa_0(9, active0, 0L);
824 }
825 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
826 {
827 if (((active0 &= old0)) == 0L)
828 return jjStartNfa_0(9, old0, 0L);
829 try { curChar = input_stream.readChar(); }
830 catch(java.io.IOException e) {
831 jjStopStringLiteralDfa_0(10, active0, 0L);
832 return 11;
833 }
834 switch(curChar)
835 {
836 case 100:
837 if ((active0 & 0x20000000000000L) != 0L)
838 return jjStartNfaWithStates_0(11, 53, 32);
839 break;
840 default :
841 break;
842 }
843 return jjStartNfa_0(10, active0, 0L);
844 }
845 private final void jjCheckNAdd(int state)
846 {
847 if (jjrounds[state] != jjround)
848 {
849 jjstateSet[jjnewStateCnt++] = state;
850 jjrounds[state] = jjround;
851 }
852 }
853 private final void jjAddStates(int start, int end)
854 {
855 do {
856 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
857 } while (start++ != end);
858 }
859 private final void jjCheckNAddTwoStates(int state1, int state2)
860 {
861 jjCheckNAdd(state1);
862 jjCheckNAdd(state2);
863 }
864 private final void jjCheckNAddStates(int start, int end)
865 {
866 do {
867 jjCheckNAdd(jjnextStates[start]);
868 } while (start++ != end);
869 }
870 private final void jjCheckNAddStates(int start)
871 {
872 jjCheckNAdd(jjnextStates[start]);
873 jjCheckNAdd(jjnextStates[start + 1]);
874 }
875 static final long[] jjbitVec0 = {
876 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
877 };
878 static final long[] jjbitVec2 = {
879 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
880 };
881 static final long[] jjbitVec3 = {
882 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
883 };
884 static final long[] jjbitVec4 = {
885 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
886 };
887 static final long[] jjbitVec5 = {
888 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
889 };
890 static final long[] jjbitVec6 = {
891 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
892 };
893 static final long[] jjbitVec7 = {
894 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
895 };
896 static final long[] jjbitVec8 = {
897 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
898 };
899 private final int jjMoveNfa_0(int startState, int curPos)
900 {
901 int[] nextStates;
902 int startsAt = 0;
903 jjnewStateCnt = 52;
904 int i = 1;
905 jjstateSet[0] = startState;
906 int j, kind = 0x7fffffff;
907 for (;;)
908 {
909 if (++jjround == 0x7fffffff)
910 ReInitRounds();
911 if (curChar < 64)
912 {
913 long l = 1L << curChar;
914 MatchLoop: do
915 {
916 switch(jjstateSet[--i])
917 {
918 case 3:
919 if ((0x3ff000000000000L & l) != 0L)
920 jjCheckNAddStates(0, 6);
921 else if (curChar == 36)
922 {
923 if (kind > 73)
924 kind = 73;
925 jjCheckNAdd(32);
926 }
927 else if (curChar == 34)
928 jjCheckNAddStates(7, 9);
929 else if (curChar == 39)
930 jjAddStates(10, 11);
931 else if (curChar == 46)
932 jjCheckNAdd(8);
933 else if (curChar == 47)
934 jjstateSet[jjnewStateCnt++] = 2;
935 if ((0x3fe000000000000L & l) != 0L)
936 {
937 if (kind > 65)
938 kind = 65;
939 jjCheckNAddTwoStates(5, 6);
940 }
941 else if (curChar == 48)
942 {
943 if (kind > 65)
944 kind = 65;
945 jjCheckNAddStates(12, 14);
946 }
947 break;
948 case 0:
949 if (curChar == 42)
950 jjstateSet[jjnewStateCnt++] = 1;
951 break;
952 case 1:
953 if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
954 kind = 7;
955 break;
956 case 2:
957 if (curChar == 42)
958 jjstateSet[jjnewStateCnt++] = 0;
959 break;
960 case 4:
961 if ((0x3fe000000000000L & l) == 0L)
962 break;
963 if (kind > 65)
964 kind = 65;
965 jjCheckNAddTwoStates(5, 6);
966 break;
967 case 5:
968 if ((0x3ff000000000000L & l) == 0L)
969 break;
970 if (kind > 65)
971 kind = 65;
972 jjCheckNAddTwoStates(5, 6);
973 break;
974 case 7:
975 if (curChar == 46)
976 jjCheckNAdd(8);
977 break;
978 case 8:
979 if ((0x3ff000000000000L & l) == 0L)
980 break;
981 if (kind > 69)
982 kind = 69;
983 jjCheckNAddStates(15, 17);
984 break;
985 case 10:
986 if ((0x280000000000L & l) != 0L)
987 jjCheckNAdd(11);
988 break;
989 case 11:
990 if ((0x3ff000000000000L & l) == 0L)
991 break;
992 if (kind > 69)
993 kind = 69;
994 jjCheckNAddTwoStates(11, 12);
995 break;
996 case 13:
997 if (curChar == 39)
998 jjAddStates(10, 11);
999 break;
1000 case 14:
1001 if ((0xffffff7fffffdbffL & l) != 0L)
1002 jjCheckNAdd(15);
1003 break;
1004 case 15:
1005 if (curChar == 39 && kind > 71)
1006 kind = 71;
1007 break;
1008 case 17:
1009 if ((0x8400000000L & l) != 0L)
1010 jjCheckNAdd(15);
1011 break;
1012 case 18:
1013 if ((0xff000000000000L & l) != 0L)
1014 jjCheckNAddTwoStates(19, 15);
1015 break;
1016 case 19:
1017 if ((0xff000000000000L & l) != 0L)
1018 jjCheckNAdd(15);
1019 break;
1020 case 20:
1021 if ((0xf000000000000L & l) != 0L)
1022 jjstateSet[jjnewStateCnt++] = 21;
1023 break;
1024 case 21:
1025 if ((0xff000000000000L & l) != 0L)
1026 jjCheckNAdd(19);
1027 break;
1028 case 22:
1029 if (curChar == 34)
1030 jjCheckNAddStates(7, 9);
1031 break;
1032 case 23:
1033 if ((0xfffffffbffffdbffL & l) != 0L)
1034 jjCheckNAddStates(7, 9);
1035 break;
1036 case 25:
1037 if ((0x8400000000L & l) != 0L)
1038 jjCheckNAddStates(7, 9);
1039 break;
1040 case 26:
1041 if (curChar == 34 && kind > 72)
1042 kind = 72;
1043 break;
1044 case 27:
1045 if ((0xff000000000000L & l) != 0L)
1046 jjCheckNAddStates(18, 21);
1047 break;
1048 case 28:
1049 if ((0xff000000000000L & l) != 0L)
1050 jjCheckNAddStates(7, 9);
1051 break;
1052 case 29:
1053 if ((0xf000000000000L & l) != 0L)
1054 jjstateSet[jjnewStateCnt++] = 30;
1055 break;
1056 case 30:
1057 if ((0xff000000000000L & l) != 0L)
1058 jjCheckNAdd(28);
1059 break;
1060 case 31:
1061 if (curChar != 36)
1062 break;
1063 if (kind > 73)
1064 kind = 73;
1065 jjCheckNAdd(32);
1066 break;
1067 case 32:
1068 if ((0x3ff001000000000L & l) == 0L)
1069 break;
1070 if (kind > 73)
1071 kind = 73;
1072 jjCheckNAdd(32);
1073 break;
1074 case 33:
1075 if ((0x3ff000000000000L & l) != 0L)
1076 jjCheckNAddStates(0, 6);
1077 break;
1078 case 34:
1079 if ((0x3ff000000000000L & l) != 0L)
1080 jjCheckNAddTwoStates(34, 35);
1081 break;
1082 case 35:
1083 if (curChar != 46)
1084 break;
1085 if (kind > 69)
1086 kind = 69;
1087 jjCheckNAddStates(22, 24);
1088 break;
1089 case 36:
1090 if ((0x3ff000000000000L & l) == 0L)
1091 break;
1092 if (kind > 69)
1093 kind = 69;
1094 jjCheckNAddStates(22, 24);
1095 break;
1096 case 38:
1097 if ((0x280000000000L & l) != 0L)
1098 jjCheckNAdd(39);
1099 break;
1100 case 39:
1101 if ((0x3ff000000000000L & l) == 0L)
1102 break;
1103 if (kind > 69)
1104 kind = 69;
1105 jjCheckNAddTwoStates(39, 12);
1106 break;
1107 case 40:
1108 if ((0x3ff000000000000L & l) != 0L)
1109 jjCheckNAddTwoStates(40, 41);
1110 break;
1111 case 42:
1112 if ((0x280000000000L & l) != 0L)
1113 jjCheckNAdd(43);
1114 break;
1115 case 43:
1116 if ((0x3ff000000000000L & l) == 0L)
1117 break;
1118 if (kind > 69)
1119 kind = 69;
1120 jjCheckNAddTwoStates(43, 12);
1121 break;
1122 case 44:
1123 if ((0x3ff000000000000L & l) != 0L)
1124 jjCheckNAddStates(25, 27);
1125 break;
1126 case 46:
1127 if ((0x280000000000L & l) != 0L)
1128 jjCheckNAdd(47);
1129 break;
1130 case 47:
1131 if ((0x3ff000000000000L & l) != 0L)
1132 jjCheckNAddTwoStates(47, 12);
1133 break;
1134 case 48:
1135 if (curChar != 48)
1136 break;
1137 if (kind > 65)
1138 kind = 65;
1139 jjCheckNAddStates(12, 14);
1140 break;
1141 case 50:
1142 if ((0x3ff000000000000L & l) == 0L)
1143 break;
1144 if (kind > 65)
1145 kind = 65;
1146 jjCheckNAddTwoStates(50, 6);
1147 break;
1148 case 51:
1149 if ((0xff000000000000L & l) == 0L)
1150 break;
1151 if (kind > 65)
1152 kind = 65;
1153 jjCheckNAddTwoStates(51, 6);
1154 break;
1155 default : break;
1156 }
1157 } while(i != startsAt);
1158 }
1159 else if (curChar < 128)
1160 {
1161 long l = 1L << (curChar & 077);
1162 MatchLoop: do
1163 {
1164 switch(jjstateSet[--i])
1165 {
1166 case 3:
1167 case 32:
1168 if ((0x7fffffe87fffffeL & l) == 0L)
1169 break;
1170 if (kind > 73)
1171 kind = 73;
1172 jjCheckNAdd(32);
1173 break;
1174 case 1:
1175 if (kind > 7)
1176 kind = 7;
1177 break;
1178 case 6:
1179 if ((0x100000001000L & l) != 0L && kind > 65)
1180 kind = 65;
1181 break;
1182 case 9:
1183 if ((0x2000000020L & l) != 0L)
1184 jjAddStates(28, 29);
1185 break;
1186 case 12:
1187 if ((0x5000000050L & l) != 0L && kind > 69)
1188 kind = 69;
1189 break;
1190 case 14:
1191 if ((0xffffffffefffffffL & l) != 0L)
1192 jjCheckNAdd(15);
1193 break;
1194 case 16:
1195 if (curChar == 92)
1196 jjAddStates(30, 32);
1197 break;
1198 case 17:
1199 if ((0x14404410000000L & l) != 0L)
1200 jjCheckNAdd(15);
1201 break;
1202 case 23:
1203 if ((0xffffffffefffffffL & l) != 0L)
1204 jjCheckNAddStates(7, 9);
1205 break;
1206 case 24:
1207 if (curChar == 92)
1208 jjAddStates(33, 35);
1209 break;
1210 case 25:
1211 if ((0x14404410000000L & l) != 0L)
1212 jjCheckNAddStates(7, 9);
1213 break;
1214 case 37:
1215 if ((0x2000000020L & l) != 0L)
1216 jjAddStates(36, 37);
1217 break;
1218 case 41:
1219 if ((0x2000000020L & l) != 0L)
1220 jjAddStates(38, 39);
1221 break;
1222 case 45:
1223 if ((0x2000000020L & l) != 0L)
1224 jjAddStates(40, 41);
1225 break;
1226 case 49:
1227 if ((0x100000001000000L & l) != 0L)
1228 jjCheckNAdd(50);
1229 break;
1230 case 50:
1231 if ((0x7e0000007eL & l) == 0L)
1232 break;
1233 if (kind > 65)
1234 kind = 65;
1235 jjCheckNAddTwoStates(50, 6);
1236 break;
1237 default : break;
1238 }
1239 } while(i != startsAt);
1240 }
1241 else
1242 {
1243 int hiByte = (int)(curChar >> 8);
1244 int i1 = hiByte >> 6;
1245 long l1 = 1L << (hiByte & 077);
1246 int i2 = (curChar & 0xff) >> 6;
1247 long l2 = 1L << (curChar & 077);
1248 MatchLoop: do
1249 {
1250 switch(jjstateSet[--i])
1251 {
1252 case 3:
1253 case 32:
1254 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1255 break;
1256 if (kind > 73)
1257 kind = 73;
1258 jjCheckNAdd(32);
1259 break;
1260 case 1:
1261 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
1262 kind = 7;
1263 break;
1264 case 14:
1265 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1266 jjstateSet[jjnewStateCnt++] = 15;
1267 break;
1268 case 23:
1269 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1270 jjAddStates(7, 9);
1271 break;
1272 default : break;
1273 }
1274 } while(i != startsAt);
1275 }
1276 if (kind != 0x7fffffff)
1277 {
1278 jjmatchedKind = kind;
1279 jjmatchedPos = curPos;
1280 kind = 0x7fffffff;
1281 }
1282 ++curPos;
1283 if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt)))
1284 return curPos;
1285 try { curChar = input_stream.readChar(); }
1286 catch(java.io.IOException e) { return curPos; }
1287 }
1288 }
1289 private final int jjMoveStringLiteralDfa0_3()
1290 {
1291 switch(curChar)
1292 {
1293 case 42:
1294 return jjMoveStringLiteralDfa1_3(0x800L);
1295 default :
1296 return 1;
1297 }
1298 }
1299 private final int jjMoveStringLiteralDfa1_3(long active0)
1300 {
1301 try { curChar = input_stream.readChar(); }
1302 catch(java.io.IOException e) {
1303 return 1;
1304 }
1305 switch(curChar)
1306 {
1307 case 47:
1308 if ((active0 & 0x800L) != 0L)
1309 return jjStopAtPos(1, 11);
1310 break;
1311 default :
1312 return 2;
1313 }
1314 return 2;
1315 }
1316 private final int jjMoveStringLiteralDfa0_1()
1317 {
1318 return jjMoveNfa_1(0, 0);
1319 }
1320 private final int jjMoveNfa_1(int startState, int curPos)
1321 {
1322 int[] nextStates;
1323 int startsAt = 0;
1324 jjnewStateCnt = 3;
1325 int i = 1;
1326 jjstateSet[0] = startState;
1327 int j, kind = 0x7fffffff;
1328 for (;;)
1329 {
1330 if (++jjround == 0x7fffffff)
1331 ReInitRounds();
1332 if (curChar < 64)
1333 {
1334 long l = 1L << curChar;
1335 MatchLoop: do
1336 {
1337 switch(jjstateSet[--i])
1338 {
1339 case 0:
1340 if ((0x2400L & l) != 0L)
1341 {
1342 if (kind > 9)
1343 kind = 9;
1344 }
1345 if (curChar == 13)
1346 jjstateSet[jjnewStateCnt++] = 1;
1347 break;
1348 case 1:
1349 if (curChar == 10 && kind > 9)
1350 kind = 9;
1351 break;
1352 case 2:
1353 if (curChar == 13)
1354 jjstateSet[jjnewStateCnt++] = 1;
1355 break;
1356 default : break;
1357 }
1358 } while(i != startsAt);
1359 }
1360 else if (curChar < 128)
1361 {
1362 long l = 1L << (curChar & 077);
1363 MatchLoop: do
1364 {
1365 switch(jjstateSet[--i])
1366 {
1367 default : break;
1368 }
1369 } while(i != startsAt);
1370 }
1371 else
1372 {
1373 int hiByte = (int)(curChar >> 8);
1374 int i1 = hiByte >> 6;
1375 long l1 = 1L << (hiByte & 077);
1376 int i2 = (curChar & 0xff) >> 6;
1377 long l2 = 1L << (curChar & 077);
1378 MatchLoop: do
1379 {
1380 switch(jjstateSet[--i])
1381 {
1382 default : break;
1383 }
1384 } while(i != startsAt);
1385 }
1386 if (kind != 0x7fffffff)
1387 {
1388 jjmatchedKind = kind;
1389 jjmatchedPos = curPos;
1390 kind = 0x7fffffff;
1391 }
1392 ++curPos;
1393 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1394 return curPos;
1395 try { curChar = input_stream.readChar(); }
1396 catch(java.io.IOException e) { return curPos; }
1397 }
1398 }
1399 private final int jjMoveStringLiteralDfa0_2()
1400 {
1401 switch(curChar)
1402 {
1403 case 42:
1404 return jjMoveStringLiteralDfa1_2(0x400L);
1405 default :
1406 return 1;
1407 }
1408 }
1409 private final int jjMoveStringLiteralDfa1_2(long active0)
1410 {
1411 try { curChar = input_stream.readChar(); }
1412 catch(java.io.IOException e) {
1413 return 1;
1414 }
1415 switch(curChar)
1416 {
1417 case 47:
1418 if ((active0 & 0x400L) != 0L)
1419 return jjStopAtPos(1, 10);
1420 break;
1421 default :
1422 return 2;
1423 }
1424 return 2;
1425 }
1426 static final int[] jjnextStates = {
1427 34, 35, 40, 41, 44, 45, 12, 23, 24, 26, 14, 16, 49, 51, 6, 8,
1428 9, 12, 23, 24, 28, 26, 36, 37, 12, 44, 45, 12, 10, 11, 17, 18,
1429 20, 25, 27, 29, 38, 39, 42, 43, 46, 47,
1430 };
1431 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1432 {
1433 switch(hiByte)
1434 {
1435 case 0:
1436 return ((jjbitVec2[i2] & l2) != 0L);
1437 default :
1438 if ((jjbitVec0[i1] & l1) != 0L)
1439 return true;
1440 return false;
1441 }
1442 }
1443 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1444 {
1445 switch(hiByte)
1446 {
1447 case 0:
1448 return ((jjbitVec4[i2] & l2) != 0L);
1449 case 48:
1450 return ((jjbitVec5[i2] & l2) != 0L);
1451 case 49:
1452 return ((jjbitVec6[i2] & l2) != 0L);
1453 case 51:
1454 return ((jjbitVec7[i2] & l2) != 0L);
1455 case 61:
1456 return ((jjbitVec8[i2] & l2) != 0L);
1457 default :
1458 if ((jjbitVec3[i1] & l1) != 0L)
1459 return true;
1460 return false;
1461 }
1462 }
1463 public static final String[] jjstrLiteralImages = {
1464 "", null, null, null, null, null, null, null, null, null, null, null, null,
1465 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145",
1466 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163",
1467 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
1468 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
1469 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154",
1470 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146",
1471 "\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",
1472 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1473 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
1474 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
1475 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162",
1476 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
1477 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164",
1478 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
1479 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", "\141\163\163\145\162\164", null, null,
1480 null, null, null, null, null, null, null, null, null, "\50", "\51", "\173", "\175",
1481 "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74", "\41", "\176", "\77", "\72",
1482 "\75\75", "\74\75", "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53",
1483 "\55", "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76",
1484 "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75",
1485 "\74\74\75", "\76\76\75", "\76\76\76\75", };
1486 public static final String[] lexStateNames = {
1487 "DEFAULT",
1488 "IN_SINGLE_LINE_COMMENT",
1489 "IN_FORMAL_COMMENT",
1490 "IN_MULTI_LINE_COMMENT",
1491 };
1492 public static final int[] jjnewLexState = {
1493 -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1494 -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,
1495 -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,
1496 -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,
1497 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1498 };
1499 static final long[] jjtoToken = {
1500 0xffffffffffffe001L, 0x3fffffffffff3a3L,
1501 };
1502 static final long[] jjtoSkip = {
1503 0xe3eL, 0x0L,
1504 };
1505 static final long[] jjtoSpecial = {
1506 0xe3eL, 0x0L,
1507 };
1508 static final long[] jjtoMore = {
1509 0x11c0L, 0x0L,
1510 };
1511 private JavaCharStream input_stream;
1512 private final int[] jjrounds = new int[52];
1513 private final int[] jjstateSet = new int[104];
1514 StringBuffer image;
1515 int jjimageLen;
1516 int lengthOfMatch;
1517 protected char curChar;
1518 public NodeParserTokenManager(JavaCharStream stream)
1519 {
1520 if (JavaCharStream.staticFlag)
1521 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1522 input_stream = stream;
1523 }
1524 public NodeParserTokenManager(JavaCharStream stream, int lexState)
1525 {
1526 this(stream);
1527 SwitchTo(lexState);
1528 }
1529 public void ReInit(JavaCharStream stream)
1530 {
1531 jjmatchedPos = jjnewStateCnt = 0;
1532 curLexState = defaultLexState;
1533 input_stream = stream;
1534 ReInitRounds();
1535 }
1536 private final void ReInitRounds()
1537 {
1538 int i;
1539 jjround = 0x80000001;
1540 for (i = 52; i-- > 0;)
1541 jjrounds[i] = 0x80000000;
1542 }
1543 public void ReInit(JavaCharStream stream, int lexState)
1544 {
1545 ReInit(stream);
1546 SwitchTo(lexState);
1547 }
1548 public void SwitchTo(int lexState)
1549 {
1550 if (lexState >= 4 || lexState < 0)
1551 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1552 else
1553 curLexState = lexState;
1554 }
1555
1556 private final Token jjFillToken()
1557 {
1558 Token t = Token.newToken(jjmatchedKind);
1559 t.kind = jjmatchedKind;
1560 String im = jjstrLiteralImages[jjmatchedKind];
1561 t.image = (im == null) ? input_stream.GetImage() : im;
1562 t.beginLine = input_stream.getBeginLine();
1563 t.beginColumn = input_stream.getBeginColumn();
1564 t.endLine = input_stream.getEndLine();
1565 t.endColumn = input_stream.getEndColumn();
1566 return t;
1567 }
1568
1569 int curLexState = 0;
1570 int defaultLexState = 0;
1571 int jjnewStateCnt;
1572 int jjround;
1573 int jjmatchedPos;
1574 int jjmatchedKind;
1575
1576 public final Token getNextToken()
1577 {
1578 int kind;
1579 Token specialToken = null;
1580 Token matchedToken;
1581 int curPos = 0;
1582
1583 EOFLoop :
1584 for (;;)
1585 {
1586 try
1587 {
1588 curChar = input_stream.BeginToken();
1589 }
1590 catch(java.io.IOException e)
1591 {
1592 jjmatchedKind = 0;
1593 matchedToken = jjFillToken();
1594 matchedToken.specialToken = specialToken;
1595 return matchedToken;
1596 }
1597 image = null;
1598 jjimageLen = 0;
1599
1600 for (;;)
1601 {
1602 switch(curLexState)
1603 {
1604 case 0:
1605 jjmatchedKind = 0x7fffffff;
1606 jjmatchedPos = 0;
1607 curPos = jjMoveStringLiteralDfa0_0();
1608 break;
1609 case 1:
1610 jjmatchedKind = 0x7fffffff;
1611 jjmatchedPos = 0;
1612 curPos = jjMoveStringLiteralDfa0_1();
1613 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1614 {
1615 jjmatchedKind = 12;
1616 }
1617 break;
1618 case 2:
1619 jjmatchedKind = 0x7fffffff;
1620 jjmatchedPos = 0;
1621 curPos = jjMoveStringLiteralDfa0_2();
1622 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1623 {
1624 jjmatchedKind = 12;
1625 }
1626 break;
1627 case 3:
1628 jjmatchedKind = 0x7fffffff;
1629 jjmatchedPos = 0;
1630 curPos = jjMoveStringLiteralDfa0_3();
1631 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1632 {
1633 jjmatchedKind = 12;
1634 }
1635 break;
1636 }
1637 if (jjmatchedKind != 0x7fffffff)
1638 {
1639 if (jjmatchedPos + 1 < curPos)
1640 input_stream.backup(curPos - jjmatchedPos - 1);
1641 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1642 {
1643 matchedToken = jjFillToken();
1644 matchedToken.specialToken = specialToken;
1645 if (jjnewLexState[jjmatchedKind] != -1)
1646 curLexState = jjnewLexState[jjmatchedKind];
1647 return matchedToken;
1648 }
1649 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1650 {
1651 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1652 {
1653 matchedToken = jjFillToken();
1654 if (specialToken == null)
1655 specialToken = matchedToken;
1656 else
1657 {
1658 matchedToken.specialToken = specialToken;
1659 specialToken = (specialToken.next = matchedToken);
1660 }
1661 SkipLexicalActions(matchedToken);
1662 }
1663 else
1664 SkipLexicalActions(null);
1665 if (jjnewLexState[jjmatchedKind] != -1)
1666 curLexState = jjnewLexState[jjmatchedKind];
1667 continue EOFLoop;
1668 }
1669 MoreLexicalActions();
1670 if (jjnewLexState[jjmatchedKind] != -1)
1671 curLexState = jjnewLexState[jjmatchedKind];
1672 curPos = 0;
1673 jjmatchedKind = 0x7fffffff;
1674 try {
1675 curChar = input_stream.readChar();
1676 continue;
1677 }
1678 catch (java.io.IOException e1) { }
1679 }
1680 int error_line = input_stream.getEndLine();
1681 int error_column = input_stream.getEndColumn();
1682 String error_after = null;
1683 boolean EOFSeen = false;
1684 try { input_stream.readChar(); input_stream.backup(1); }
1685 catch (java.io.IOException e1) {
1686 EOFSeen = true;
1687 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1688 if (curChar == '\n' || curChar == '\r') {
1689 error_line++;
1690 error_column = 0;
1691 }
1692 else
1693 error_column++;
1694 }
1695 if (!EOFSeen) {
1696 input_stream.backup(1);
1697 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1698 }
1699 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1700 }
1701 }
1702 }
1703
1704 final void SkipLexicalActions(Token matchedToken)
1705 {
1706 switch(jjmatchedKind)
1707 {
1708 default :
1709 break;
1710 }
1711 }
1712 final void MoreLexicalActions()
1713 {
1714 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1715 switch(jjmatchedKind)
1716 {
1717 case 7 :
1718 if (image == null)
1719 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
1720 else
1721 image.append(input_stream.GetSuffix(jjimageLen));
1722 jjimageLen = 0;
1723 input_stream.backup(1);
1724 break;
1725 default :
1726 break;
1727 }
1728 }
1729 }