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