1
2 package net.sourceforge.pmd.lang.cpp.ast;
3 import net.sourceforge.pmd.lang.ast.CharStream;
4 import net.sourceforge.pmd.lang.ast.TokenMgrError;
5
6
7 public class CppParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements CppParserConstants
8 {
9
10
11 public java.io.PrintStream debugStream = System.out;
12
13 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
14 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2)
15 {
16 switch (pos)
17 {
18 case 0:
19 if ((active1 & 0x7fffffffffffe0L) != 0L || (active2 & 0x100L) != 0L)
20 {
21 jjmatchedKind = 137;
22 return 19;
23 }
24 if ((active0 & 0x80000000L) != 0L || (active1 & 0xaL) != 0L)
25 return 1;
26 return -1;
27 case 1:
28 if ((active1 & 0x7fffffff7f3fe0L) != 0L || (active2 & 0x100L) != 0L)
29 {
30 if (jjmatchedPos != 1)
31 {
32 jjmatchedKind = 137;
33 jjmatchedPos = 1;
34 }
35 return 19;
36 }
37 if ((active1 & 0x80c000L) != 0L)
38 return 19;
39 return -1;
40 case 2:
41 if ((active1 & 0x7ff7fff56fbfe0L) != 0L || (active2 & 0x100L) != 0L)
42 {
43 jjmatchedKind = 137;
44 jjmatchedPos = 2;
45 return 19;
46 }
47 if ((active1 & 0x8000a100000L) != 0L)
48 return 19;
49 return -1;
50 case 3:
51 if ((active1 & 0x6ef3fff12cbd40L) != 0L || (active2 & 0x100L) != 0L)
52 {
53 jjmatchedKind = 137;
54 jjmatchedPos = 3;
55 return 19;
56 }
57 if ((active1 & 0x110400044302a0L) != 0L)
58 return 19;
59 return -1;
60 case 4:
61 if ((active1 & 0xad37bf124b800L) != 0L || (active2 & 0x100L) != 0L)
62 {
63 jjmatchedKind = 137;
64 jjmatchedPos = 4;
65 return 19;
66 }
67 if ((active1 & 0x64208400080540L) != 0L)
68 return 19;
69 return -1;
70 case 5:
71 if ((active1 & 0x17a4124a000L) != 0L)
72 return 19;
73 if ((active1 & 0xad201b0001800L) != 0L || (active2 & 0x100L) != 0L)
74 {
75 jjmatchedKind = 137;
76 jjmatchedPos = 5;
77 return 19;
78 }
79 return -1;
80 case 6:
81 if ((active1 & 0xa4201a0000800L) != 0L)
82 {
83 jjmatchedKind = 137;
84 jjmatchedPos = 6;
85 return 19;
86 }
87 if ((active1 & 0x900010001000L) != 0L || (active2 & 0x100L) != 0L)
88 return 19;
89 return -1;
90 case 7:
91 if ((active1 & 0xa0000000L) != 0L)
92 {
93 jjmatchedKind = 137;
94 jjmatchedPos = 7;
95 return 19;
96 }
97 if ((active1 & 0xa420100000800L) != 0L)
98 return 19;
99 return -1;
100 case 8:
101 if ((active1 & 0x80000000L) != 0L)
102 {
103 jjmatchedKind = 137;
104 jjmatchedPos = 8;
105 return 19;
106 }
107 if ((active1 & 0x20000000L) != 0L)
108 return 19;
109 return -1;
110 default :
111 return -1;
112 }
113 }
114 private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
115 {
116 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
117 }
118 private int jjStopAtPos(int pos, int kind)
119 {
120 jjmatchedKind = kind;
121 jjmatchedPos = pos;
122 return pos + 1;
123 }
124 private int jjMoveStringLiteralDfa0_0()
125 {
126 switch(curChar)
127 {
128 case 13:
129 return jjMoveStringLiteralDfa1_0(0x10L, 0x0L, 0x0L);
130 case 33:
131 jjmatchedKind = 64;
132 return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L, 0x0L);
133 case 35:
134 return jjStopAtPos(0, 8);
135 case 37:
136 jjmatchedKind = 60;
137 return jjMoveStringLiteralDfa1_0(0x800000000L, 0x0L, 0x0L);
138 case 38:
139 jjmatchedKind = 47;
140 return jjMoveStringLiteralDfa1_0(0x110000000000L, 0x0L, 0x0L);
141 case 40:
142 return jjStopAtPos(0, 24);
143 case 41:
144 return jjStopAtPos(0, 25);
145 case 42:
146 jjmatchedKind = 58;
147 return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L, 0x0L);
148 case 43:
149 jjmatchedKind = 56;
150 return jjMoveStringLiteralDfa1_0(0x2000001000000000L, 0x0L, 0x0L);
151 case 44:
152 return jjStopAtPos(0, 29);
153 case 45:
154 jjmatchedKind = 57;
155 return jjMoveStringLiteralDfa1_0(0x4000002000000000L, 0x14L, 0x0L);
156 case 46:
157 jjmatchedKind = 65;
158 return jjMoveStringLiteralDfa1_0(0x80000000L, 0x8L, 0x0L);
159 case 47:
160 jjmatchedKind = 59;
161 return jjMoveStringLiteralDfa1_0(0x4000000c0L, 0x0L, 0x0L);
162 case 58:
163 jjmatchedKind = 27;
164 return jjMoveStringLiteralDfa1_0(0x4000000L, 0x0L, 0x0L);
165 case 59:
166 return jjStopAtPos(0, 28);
167 case 60:
168 jjmatchedKind = 50;
169 return jjMoveStringLiteralDfa1_0(0x50004000000000L, 0x0L, 0x0L);
170 case 61:
171 jjmatchedKind = 32;
172 return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L, 0x0L);
173 case 62:
174 jjmatchedKind = 51;
175 return jjMoveStringLiteralDfa1_0(0xa0008000000000L, 0x0L, 0x0L);
176 case 63:
177 return jjStopAtPos(0, 30);
178 case 64:
179 return jjStopAtPos(0, 119);
180 case 91:
181 return jjStopAtPos(0, 22);
182 case 93:
183 return jjStopAtPos(0, 23);
184 case 94:
185 jjmatchedKind = 46;
186 return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L, 0x0L);
187 case 97:
188 return jjMoveStringLiteralDfa1_0(0x0L, 0x20L, 0x0L);
189 case 98:
190 return jjMoveStringLiteralDfa1_0(0x0L, 0x40L, 0x0L);
191 case 99:
192 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000f80L, 0x0L);
193 case 100:
194 return jjMoveStringLiteralDfa1_0(0x0L, 0xf000L, 0x0L);
195 case 101:
196 return jjMoveStringLiteralDfa1_0(0x0L, 0x70000L, 0x0L);
197 case 102:
198 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000380000L, 0x100L);
199 case 103:
200 return jjMoveStringLiteralDfa1_0(0x0L, 0x400000L, 0x0L);
201 case 105:
202 return jjMoveStringLiteralDfa1_0(0x0L, 0x3800000L, 0x0L);
203 case 108:
204 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L, 0x0L);
205 case 110:
206 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L, 0x0L);
207 case 111:
208 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L, 0x0L);
209 case 112:
210 return jjMoveStringLiteralDfa1_0(0x0L, 0x70000000L, 0x0L);
211 case 114:
212 return jjMoveStringLiteralDfa1_0(0x0L, 0x380000000L, 0x0L);
213 case 115:
214 return jjMoveStringLiteralDfa1_0(0x0L, 0x17c00000000L, 0x0L);
215 case 116:
216 return jjMoveStringLiteralDfa1_0(0x0L, 0x501e0000000000L, 0x0L);
217 case 117:
218 return jjMoveStringLiteralDfa1_0(0x0L, 0x600000000000L, 0x0L);
219 case 118:
220 return jjMoveStringLiteralDfa1_0(0x0L, 0x3800000000000L, 0x0L);
221 case 119:
222 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L, 0x0L);
223 case 123:
224 return jjStopAtPos(0, 20);
225 case 124:
226 jjmatchedKind = 45;
227 return jjMoveStringLiteralDfa1_0(0xc0000000000L, 0x0L, 0x0L);
228 case 125:
229 return jjStopAtPos(0, 21);
230 case 126:
231 return jjStopAtPos(0, 63);
232 default :
233 return jjMoveNfa_0(18, 0);
234 }
235 }
236 private 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 & 0x10L) != 0L)
247 return jjStopAtPos(1, 4);
248 break;
249 case 38:
250 if ((active0 & 0x100000000000L) != 0L)
251 return jjStopAtPos(1, 44);
252 break;
253 case 42:
254 if ((active0 & 0x80L) != 0L)
255 return jjStopAtPos(1, 7);
256 else if ((active1 & 0x8L) != 0L)
257 return jjStopAtPos(1, 67);
258 break;
259 case 43:
260 if ((active0 & 0x2000000000000000L) != 0L)
261 return jjStopAtPos(1, 61);
262 break;
263 case 45:
264 if ((active0 & 0x4000000000000000L) != 0L)
265 return jjStopAtPos(1, 62);
266 break;
267 case 46:
268 return jjMoveStringLiteralDfa2_0(active0, 0x80000000L, active1, 0L, active2, 0L);
269 case 47:
270 if ((active0 & 0x40L) != 0L)
271 return jjStopAtPos(1, 6);
272 break;
273 case 58:
274 if ((active0 & 0x4000000L) != 0L)
275 return jjStopAtPos(1, 26);
276 break;
277 case 60:
278 if ((active0 & 0x40000000000000L) != 0L)
279 {
280 jjmatchedKind = 54;
281 jjmatchedPos = 1;
282 }
283 return jjMoveStringLiteralDfa2_0(active0, 0x4000000000L, active1, 0L, active2, 0L);
284 case 61:
285 if ((active0 & 0x200000000L) != 0L)
286 return jjStopAtPos(1, 33);
287 else if ((active0 & 0x400000000L) != 0L)
288 return jjStopAtPos(1, 34);
289 else if ((active0 & 0x800000000L) != 0L)
290 return jjStopAtPos(1, 35);
291 else if ((active0 & 0x1000000000L) != 0L)
292 return jjStopAtPos(1, 36);
293 else if ((active0 & 0x2000000000L) != 0L)
294 return jjStopAtPos(1, 37);
295 else if ((active0 & 0x10000000000L) != 0L)
296 return jjStopAtPos(1, 40);
297 else if ((active0 & 0x20000000000L) != 0L)
298 return jjStopAtPos(1, 41);
299 else if ((active0 & 0x40000000000L) != 0L)
300 return jjStopAtPos(1, 42);
301 else if ((active0 & 0x1000000000000L) != 0L)
302 return jjStopAtPos(1, 48);
303 else if ((active0 & 0x2000000000000L) != 0L)
304 return jjStopAtPos(1, 49);
305 else if ((active0 & 0x10000000000000L) != 0L)
306 return jjStopAtPos(1, 52);
307 else if ((active0 & 0x20000000000000L) != 0L)
308 return jjStopAtPos(1, 53);
309 break;
310 case 62:
311 if ((active0 & 0x80000000000000L) != 0L)
312 {
313 jjmatchedKind = 55;
314 jjmatchedPos = 1;
315 }
316 else if ((active1 & 0x4L) != 0L)
317 {
318 jjmatchedKind = 66;
319 jjmatchedPos = 1;
320 }
321 return jjMoveStringLiteralDfa2_0(active0, 0x8000000000L, active1, 0x10L, active2, 0L);
322 case 97:
323 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000000000180L, active2, 0L);
324 case 101:
325 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20388003000L, active2, 0L);
326 case 102:
327 if ((active1 & 0x800000L) != 0L)
328 return jjStartNfaWithStates_0(1, 87, 19);
329 break;
330 case 104:
331 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x44040400000200L, active2, 0L);
332 case 105:
333 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x801800000000L, active2, 0x100L);
334 case 108:
335 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000090000L, active2, 0L);
336 case 110:
337 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x600003020000L, active2, 0L);
338 case 111:
339 if ((active1 & 0x4000L) != 0L)
340 {
341 jjmatchedKind = 78;
342 jjmatchedPos = 1;
343 }
344 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x3000004508c00L, active2, 0L);
345 case 112:
346 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000000000000L, active2, 0L);
347 case 114:
348 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10080030200040L, active2, 0L);
349 case 116:
350 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x6000000000L, active2, 0L);
351 case 117:
352 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000020L, active2, 0L);
353 case 119:
354 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10000000000L, active2, 0L);
355 case 120:
356 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000L, active2, 0L);
357 case 121:
358 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100000000000L, active2, 0L);
359 case 124:
360 if ((active0 & 0x80000000000L) != 0L)
361 return jjStopAtPos(1, 43);
362 break;
363 default :
364 break;
365 }
366 return jjStartNfa_0(0, active0, active1, active2);
367 }
368 private 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 & 0x10L) != 0L)
381 return jjStopAtPos(2, 68);
382 break;
383 case 46:
384 if ((active0 & 0x80000000L) != 0L)
385 return jjStopAtPos(2, 31);
386 break;
387 case 61:
388 if ((active0 & 0x4000000000L) != 0L)
389 return jjStopAtPos(2, 38);
390 else if ((active0 & 0x8000000000L) != 0L)
391 return jjStopAtPos(2, 39);
392 break;
393 case 97:
394 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0xa000000200L, active2, 0L);
395 case 98:
396 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40000000L, active2, 0L);
397 case 100:
398 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x80000000L, active2, 0L);
399 case 101:
400 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000000040L, active2, 0L);
401 case 102:
402 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1000L, active2, 0L);
403 case 103:
404 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x900000000L, active2, 0L);
405 case 105:
406 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x5250010200000L, active2, 0L);
407 case 108:
408 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x22000001002000L, active2, 0L);
409 case 109:
410 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20000000000L, active2, 0L);
411 case 110:
412 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4000c00L, active2, 0x100L);
413 case 111:
414 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x420080000L, active2, 0L);
415 case 112:
416 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x100000000000L, active2, 0L);
417 case 114:
418 if ((active1 & 0x100000L) != 0L)
419 return jjStartNfaWithStates_0(2, 84, 19);
420 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40804000000000L, active2, 0L);
421 case 115:
422 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400000010080L, active2, 0L);
423 case 116:
424 if ((active1 & 0x2000000L) != 0L)
425 return jjStartNfaWithStates_0(2, 89, 19);
426 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200440120L, active2, 0L);
427 case 117:
428 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x10000000028000L, active2, 0L);
429 case 119:
430 if ((active1 & 0x8000000L) != 0L)
431 return jjStartNfaWithStates_0(2, 91, 19);
432 break;
433 case 121:
434 if ((active1 & 0x80000000000L) != 0L)
435 return jjStartNfaWithStates_0(2, 107, 19);
436 break;
437 case 122:
438 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1000000000L, active2, 0L);
439 default :
440 break;
441 }
442 return jjStartNfa_0(1, active0, active1, active2);
443 }
444 private 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, 0x2000000081040L, active2, 0x100L);
457 case 98:
458 return jjMoveStringLiteralDfa4_0(active1, 0x8000L, active2, 0L);
459 case 99:
460 return jjMoveStringLiteralDfa4_0(active1, 0x100L, active2, 0L);
461 case 100:
462 if ((active1 & 0x1000000000000L) != 0L)
463 return jjStartNfaWithStates_0(3, 112, 19);
464 break;
465 case 101:
466 if ((active1 & 0x80L) != 0L)
467 return jjStartNfaWithStates_0(3, 71, 19);
468 else if ((active1 & 0x10000L) != 0L)
469 return jjStartNfaWithStates_0(3, 80, 19);
470 else if ((active1 & 0x10000000000000L) != 0L)
471 return jjStartNfaWithStates_0(3, 116, 19);
472 return jjMoveStringLiteralDfa4_0(active1, 0x101080242000L, active2, 0L);
473 case 103:
474 if ((active1 & 0x4000000L) != 0L)
475 return jjStartNfaWithStates_0(3, 90, 19);
476 break;
477 case 105:
478 return jjMoveStringLiteralDfa4_0(active1, 0x400101000000L, active2, 0L);
479 case 108:
480 return jjMoveStringLiteralDfa4_0(active1, 0x4000040000000L, active2, 0L);
481 case 109:
482 if ((active1 & 0x20000L) != 0L)
483 return jjStartNfaWithStates_0(3, 81, 19);
484 break;
485 case 110:
486 return jjMoveStringLiteralDfa4_0(active1, 0x800000000L, active2, 0L);
487 case 111:
488 if ((active1 & 0x20L) != 0L)
489 return jjStartNfaWithStates_0(3, 69, 19);
490 else if ((active1 & 0x400000L) != 0L)
491 return jjStartNfaWithStates_0(3, 86, 19);
492 return jjMoveStringLiteralDfa4_0(active1, 0x40200000000000L, active2, 0L);
493 case 112:
494 return jjMoveStringLiteralDfa4_0(active1, 0x20000000000L, active2, 0L);
495 case 114:
496 if ((active1 & 0x200L) != 0L)
497 return jjStartNfaWithStates_0(3, 73, 19);
498 return jjMoveStringLiteralDfa4_0(active1, 0x8000400000000L, active2, 0L);
499 case 115:
500 if ((active1 & 0x40000000000L) != 0L)
501 return jjStartNfaWithStates_0(3, 106, 19);
502 return jjMoveStringLiteralDfa4_0(active1, 0x20008000000400L, active2, 0L);
503 case 116:
504 return jjMoveStringLiteralDfa4_0(active1, 0x812020000800L, active2, 0L);
505 case 117:
506 return jjMoveStringLiteralDfa4_0(active1, 0x4200000000L, active2, 0L);
507 case 118:
508 return jjMoveStringLiteralDfa4_0(active1, 0x10000000L, active2, 0L);
509 default :
510 break;
511 }
512 return jjStartNfa_0(2, 0L, active1, active2);
513 }
514 private 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, 0x8000010000000L, active2, 0L);
527 case 99:
528 return jjMoveStringLiteralDfa5_0(active1, 0x14080000000L, active2, 0L);
529 case 100:
530 return jjMoveStringLiteralDfa5_0(active1, 0x100000000000L, active2, 0L);
531 case 101:
532 if ((active1 & 0x4000000000000L) != 0L)
533 return jjStartNfaWithStates_0(4, 114, 19);
534 else if ((active1 & 0x20000000000000L) != 0L)
535 return jjStartNfaWithStates_0(4, 117, 19);
536 return jjMoveStringLiteralDfa5_0(active1, 0x820000000L, active2, 0L);
537 case 103:
538 return jjMoveStringLiteralDfa5_0(active1, 0x400000000000L, active2, 0L);
539 case 104:
540 if ((active1 & 0x100L) != 0L)
541 return jjStartNfaWithStates_0(4, 72, 19);
542 break;
543 case 105:
544 return jjMoveStringLiteralDfa5_0(active1, 0x2040000800L, active2, 0L);
545 case 107:
546 if ((active1 & 0x40L) != 0L)
547 return jjStartNfaWithStates_0(4, 70, 19);
548 break;
549 case 108:
550 return jjMoveStringLiteralDfa5_0(active1, 0x20000008000L, active2, 0x100L);
551 case 110:
552 if ((active1 & 0x200000000000L) != 0L)
553 return jjStartNfaWithStates_0(4, 109, 19);
554 return jjMoveStringLiteralDfa5_0(active1, 0x1200000L, active2, 0L);
555 case 111:
556 return jjMoveStringLiteralDfa5_0(active1, 0x1000000000L, active2, 0L);
557 case 114:
558 return jjMoveStringLiteralDfa5_0(active1, 0x200040000L, active2, 0L);
559 case 115:
560 if ((active1 & 0x8000000000L) != 0L)
561 return jjStartNfaWithStates_0(4, 103, 19);
562 return jjMoveStringLiteralDfa5_0(active1, 0x100000000L, active2, 0L);
563 case 116:
564 if ((active1 & 0x400L) != 0L)
565 return jjStartNfaWithStates_0(4, 74, 19);
566 else if ((active1 & 0x80000L) != 0L)
567 return jjStartNfaWithStates_0(4, 83, 19);
568 else if ((active1 & 0x400000000L) != 0L)
569 return jjStartNfaWithStates_0(4, 98, 19);
570 return jjMoveStringLiteralDfa5_0(active1, 0x2000000002000L, active2, 0L);
571 case 117:
572 return jjMoveStringLiteralDfa5_0(active1, 0x800000001000L, active2, 0L);
573 case 119:
574 if ((active1 & 0x40000000000000L) != 0L)
575 return jjStartNfaWithStates_0(4, 118, 19);
576 break;
577 default :
578 break;
579 }
580 return jjStartNfa_0(3, 0L, active1, active2);
581 }
582 private 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, 0x820000000000L, active2, 0L);
595 case 99:
596 if ((active1 & 0x40000000L) != 0L)
597 return jjStartNfaWithStates_0(5, 94, 19);
598 else if ((active1 & 0x2000000000L) != 0L)
599 return jjStartNfaWithStates_0(5, 101, 19);
600 return jjMoveStringLiteralDfa6_0(active1, 0x20000000L, active2, 0L);
601 case 100:
602 if ((active1 & 0x200000L) != 0L)
603 return jjStartNfaWithStates_0(5, 85, 19);
604 else if ((active1 & 0x800000000L) != 0L)
605 return jjStartNfaWithStates_0(5, 99, 19);
606 break;
607 case 101:
608 if ((active1 & 0x2000L) != 0L)
609 return jjStartNfaWithStates_0(5, 77, 19);
610 else if ((active1 & 0x8000L) != 0L)
611 return jjStartNfaWithStates_0(5, 79, 19);
612 else if ((active1 & 0x1000000L) != 0L)
613 return jjStartNfaWithStates_0(5, 88, 19);
614 return jjMoveStringLiteralDfa6_0(active1, 0x100000000000L, active2, 0L);
615 case 102:
616 if ((active1 & 0x1000000000L) != 0L)
617 return jjStartNfaWithStates_0(5, 100, 19);
618 break;
619 case 104:
620 if ((active1 & 0x10000000000L) != 0L)
621 return jjStartNfaWithStates_0(5, 104, 19);
622 break;
623 case 105:
624 return jjMoveStringLiteralDfa6_0(active1, 0x2000000000000L, active2, 0L);
625 case 108:
626 return jjMoveStringLiteralDfa6_0(active1, 0x80001000L, active2, 0x100L);
627 case 110:
628 if ((active1 & 0x40000L) != 0L)
629 return jjStartNfaWithStates_0(5, 82, 19);
630 else if ((active1 & 0x200000000L) != 0L)
631 return jjStartNfaWithStates_0(5, 97, 19);
632 return jjMoveStringLiteralDfa6_0(active1, 0x400000000800L, active2, 0L);
633 case 116:
634 if ((active1 & 0x4000000000L) != 0L)
635 return jjStartNfaWithStates_0(5, 102, 19);
636 return jjMoveStringLiteralDfa6_0(active1, 0x8000110000000L, active2, 0L);
637 default :
638 break;
639 }
640 return jjStartNfa_0(4, 0L, active1, active2);
641 }
642 private 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, 0x80000000L, active2, 0L);
655 case 101:
656 if ((active1 & 0x10000000L) != 0L)
657 return jjStartNfaWithStates_0(6, 92, 19);
658 return jjMoveStringLiteralDfa7_0(active1, 0x400100000000L, active2, 0L);
659 case 102:
660 if ((active1 & 0x100000000000L) != 0L)
661 return jjStartNfaWithStates_0(6, 108, 19);
662 break;
663 case 108:
664 if ((active1 & 0x800000000000L) != 0L)
665 return jjStartNfaWithStates_0(6, 111, 19);
666 return jjMoveStringLiteralDfa7_0(active1, 0x2000000000000L, active2, 0L);
667 case 111:
668 return jjMoveStringLiteralDfa7_0(active1, 0x8000000000000L, active2, 0L);
669 case 116:
670 if ((active1 & 0x1000L) != 0L)
671 return jjStartNfaWithStates_0(6, 76, 19);
672 return jjMoveStringLiteralDfa7_0(active1, 0x20020000000L, active2, 0L);
673 case 117:
674 return jjMoveStringLiteralDfa7_0(active1, 0x800L, active2, 0L);
675 case 121:
676 if ((active2 & 0x100L) != 0L)
677 return jjStartNfaWithStates_0(6, 136, 19);
678 break;
679 default :
680 break;
681 }
682 return jjStartNfa_0(5, 0L, active1, active2);
683 }
684 private 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 & 0x400000000000L) != 0L)
697 return jjStartNfaWithStates_0(7, 110, 19);
698 break;
699 case 101:
700 if ((active1 & 0x800L) != 0L)
701 return jjStartNfaWithStates_0(7, 75, 19);
702 else if ((active1 & 0x20000000000L) != 0L)
703 return jjStartNfaWithStates_0(7, 105, 19);
704 else if ((active1 & 0x2000000000000L) != 0L)
705 return jjStartNfaWithStates_0(7, 113, 19);
706 return jjMoveStringLiteralDfa8_0(active1, 0x20000000L);
707 case 114:
708 if ((active1 & 0x100000000L) != 0L)
709 return jjStartNfaWithStates_0(7, 96, 19);
710 else if ((active1 & 0x8000000000000L) != 0L)
711 return jjStartNfaWithStates_0(7, 115, 19);
712 return jjMoveStringLiteralDfa8_0(active1, 0x80000000L);
713 default :
714 break;
715 }
716 return jjStartNfa_0(6, 0L, active1, 0L);
717 }
718 private 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 & 0x20000000L) != 0L)
731 return jjStartNfaWithStates_0(8, 93, 19);
732 break;
733 case 101:
734 return jjMoveStringLiteralDfa9_0(active1, 0x80000000L);
735 default :
736 break;
737 }
738 return jjStartNfa_0(7, 0L, active1, 0L);
739 }
740 private 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 & 0x80000000L) != 0L)
753 return jjStartNfaWithStates_0(9, 95, 19);
754 break;
755 default :
756 break;
757 }
758 return jjStartNfa_0(8, 0L, active1, 0L);
759 }
760 private int jjStartNfaWithStates_0(int pos, int kind, int state)
761 {
762 jjmatchedKind = kind;
763 jjmatchedPos = pos;
764 try { curChar = input_stream.readChar(); }
765 catch(java.io.IOException e) { return pos + 1; }
766 return jjMoveNfa_0(state, pos + 1);
767 }
768 static final long[] jjbitVec0 = {
769 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
770 };
771 static final long[] jjbitVec2 = {
772 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
773 };
774 private int jjMoveNfa_0(int startState, int curPos)
775 {
776 int startsAt = 0;
777 jjnewStateCnt = 68;
778 int i = 1;
779 jjstateSet[0] = startState;
780 int kind = 0x7fffffff;
781 for (;;)
782 {
783 if (++jjround == 0x7fffffff)
784 ReInitRounds();
785 if (curChar < 64)
786 {
787 long l = 1L << curChar;
788 do
789 {
790 switch(jjstateSet[--i])
791 {
792 case 18:
793 if ((0x3ff000000000000L & l) != 0L)
794 jjCheckNAddStates(0, 5);
795 else if (curChar == 36)
796 {
797 if (kind > 137)
798 kind = 137;
799 jjCheckNAdd(19);
800 }
801 else if (curChar == 34)
802 jjCheckNAddStates(6, 8);
803 else if (curChar == 39)
804 jjCheckNAddStates(9, 11);
805 else if (curChar == 46)
806 jjCheckNAdd(1);
807 if ((0x3fe000000000000L & l) != 0L)
808 {
809 if (kind > 124)
810 kind = 124;
811 jjCheckNAddStates(12, 19);
812 }
813 else if (curChar == 48)
814 jjAddStates(20, 23);
815 if (curChar == 48)
816 {
817 if (kind > 120)
818 kind = 120;
819 jjCheckNAddStates(24, 31);
820 }
821 break;
822 case 0:
823 if (curChar == 46)
824 jjCheckNAdd(1);
825 break;
826 case 1:
827 if ((0x3ff000000000000L & l) == 0L)
828 break;
829 if (kind > 132)
830 kind = 132;
831 jjCheckNAddStates(32, 34);
832 break;
833 case 3:
834 if ((0x280000000000L & l) != 0L)
835 jjCheckNAdd(4);
836 break;
837 case 4:
838 if ((0x3ff000000000000L & l) == 0L)
839 break;
840 if (kind > 132)
841 kind = 132;
842 jjCheckNAddTwoStates(4, 5);
843 break;
844 case 6:
845 if (curChar == 39)
846 jjCheckNAddStates(9, 11);
847 break;
848 case 7:
849 if ((0xffffff7fffffdbffL & l) != 0L)
850 jjCheckNAddStates(9, 11);
851 break;
852 case 9:
853 if ((0xffffffffffffdbffL & l) != 0L)
854 jjCheckNAddStates(9, 11);
855 break;
856 case 10:
857 if (curChar == 39 && kind > 134)
858 kind = 134;
859 break;
860 case 11:
861 if (curChar == 34)
862 jjCheckNAddStates(6, 8);
863 break;
864 case 12:
865 if ((0xfffffffbffffdbffL & l) != 0L)
866 jjCheckNAddStates(6, 8);
867 break;
868 case 14:
869 if ((0xffffffffffffdfffL & l) != 0L)
870 jjCheckNAddStates(6, 8);
871 break;
872 case 15:
873 if (curChar == 34 && kind > 135)
874 kind = 135;
875 break;
876 case 16:
877 if (curChar == 10)
878 jjCheckNAddStates(6, 8);
879 break;
880 case 17:
881 if (curChar == 13)
882 jjstateSet[jjnewStateCnt++] = 16;
883 break;
884 case 19:
885 if ((0x3ff001000000000L & l) == 0L)
886 break;
887 if (kind > 137)
888 kind = 137;
889 jjCheckNAdd(19);
890 break;
891 case 20:
892 if (curChar != 48)
893 break;
894 if (kind > 120)
895 kind = 120;
896 jjCheckNAddStates(24, 31);
897 break;
898 case 21:
899 if ((0xff000000000000L & l) == 0L)
900 break;
901 if (kind > 120)
902 kind = 120;
903 jjCheckNAdd(21);
904 break;
905 case 22:
906 if ((0xff000000000000L & l) != 0L)
907 jjCheckNAddTwoStates(22, 23);
908 break;
909 case 24:
910 if ((0xff000000000000L & l) != 0L)
911 jjCheckNAddTwoStates(24, 25);
912 break;
913 case 26:
914 if ((0xff000000000000L & l) != 0L)
915 jjCheckNAddStates(35, 37);
916 break;
917 case 31:
918 if ((0x3fe000000000000L & l) == 0L)
919 break;
920 if (kind > 124)
921 kind = 124;
922 jjCheckNAddStates(12, 19);
923 break;
924 case 32:
925 if ((0x3ff000000000000L & l) == 0L)
926 break;
927 if (kind > 124)
928 kind = 124;
929 jjCheckNAdd(32);
930 break;
931 case 33:
932 if ((0x3ff000000000000L & l) != 0L)
933 jjCheckNAddTwoStates(33, 34);
934 break;
935 case 35:
936 if ((0x3ff000000000000L & l) != 0L)
937 jjCheckNAddTwoStates(35, 36);
938 break;
939 case 37:
940 if ((0x3ff000000000000L & l) != 0L)
941 jjCheckNAddStates(38, 40);
942 break;
943 case 42:
944 if (curChar == 48)
945 jjAddStates(20, 23);
946 break;
947 case 44:
948 if ((0x3ff000000000000L & l) == 0L)
949 break;
950 if (kind > 128)
951 kind = 128;
952 jjstateSet[jjnewStateCnt++] = 44;
953 break;
954 case 46:
955 if ((0x3ff000000000000L & l) == 0L)
956 break;
957 if (kind > 129)
958 kind = 129;
959 jjAddStates(41, 42);
960 break;
961 case 49:
962 if ((0x3ff000000000000L & l) != 0L)
963 jjAddStates(43, 44);
964 break;
965 case 52:
966 if ((0x3ff000000000000L & l) != 0L)
967 jjAddStates(45, 47);
968 break;
969 case 57:
970 if ((0x3ff000000000000L & l) != 0L)
971 jjCheckNAddStates(0, 5);
972 break;
973 case 58:
974 if ((0x3ff000000000000L & l) != 0L)
975 jjCheckNAddTwoStates(58, 59);
976 break;
977 case 59:
978 if (curChar != 46)
979 break;
980 if (kind > 132)
981 kind = 132;
982 jjCheckNAddStates(48, 50);
983 break;
984 case 60:
985 if ((0x3ff000000000000L & l) == 0L)
986 break;
987 if (kind > 132)
988 kind = 132;
989 jjCheckNAddStates(48, 50);
990 break;
991 case 61:
992 if ((0x3ff000000000000L & l) != 0L)
993 jjCheckNAddTwoStates(61, 0);
994 break;
995 case 62:
996 if ((0x3ff000000000000L & l) != 0L)
997 jjCheckNAddTwoStates(62, 63);
998 break;
999 case 64:
1000 if ((0x280000000000L & l) != 0L)
1001 jjCheckNAdd(65);
1002 break;
1003 case 65:
1004 if ((0x3ff000000000000L & l) == 0L)
1005 break;
1006 if (kind > 133)
1007 kind = 133;
1008 jjCheckNAddTwoStates(65, 66);
1009 break;
1010 default : break;
1011 }
1012 } while(i != startsAt);
1013 }
1014 else if (curChar < 128)
1015 {
1016 long l = 1L << (curChar & 077);
1017 do
1018 {
1019 switch(jjstateSet[--i])
1020 {
1021 case 18:
1022 if ((0x7fffffe87fffffeL & l) != 0L)
1023 {
1024 if (kind > 137)
1025 kind = 137;
1026 jjCheckNAdd(19);
1027 }
1028 if (curChar == 76)
1029 jjAddStates(51, 52);
1030 break;
1031 case 2:
1032 if ((0x2000000020L & l) != 0L)
1033 jjAddStates(53, 54);
1034 break;
1035 case 5:
1036 if ((0x104000001040L & l) != 0L && kind > 132)
1037 kind = 132;
1038 break;
1039 case 7:
1040 if ((0xffffffffefffffffL & l) != 0L)
1041 jjCheckNAddStates(9, 11);
1042 break;
1043 case 8:
1044 if (curChar == 92)
1045 jjstateSet[jjnewStateCnt++] = 9;
1046 break;
1047 case 9:
1048 jjCheckNAddStates(9, 11);
1049 break;
1050 case 12:
1051 if ((0xffffffffefffffffL & l) != 0L)
1052 jjCheckNAddStates(6, 8);
1053 break;
1054 case 13:
1055 if (curChar == 92)
1056 jjAddStates(55, 56);
1057 break;
1058 case 14:
1059 jjCheckNAddStates(6, 8);
1060 break;
1061 case 19:
1062 if ((0x7fffffe87fffffeL & l) == 0L)
1063 break;
1064 if (kind > 137)
1065 kind = 137;
1066 jjCheckNAdd(19);
1067 break;
1068 case 23:
1069 if ((0x100000001000L & l) != 0L && kind > 121)
1070 kind = 121;
1071 break;
1072 case 25:
1073 if ((0x20000000200000L & l) != 0L && kind > 122)
1074 kind = 122;
1075 break;
1076 case 27:
1077 if ((0x100000001000L & l) != 0L && kind > 123)
1078 kind = 123;
1079 break;
1080 case 28:
1081 if ((0x20000000200000L & l) != 0L)
1082 jjstateSet[jjnewStateCnt++] = 27;
1083 break;
1084 case 29:
1085 if ((0x20000000200000L & l) != 0L && kind > 123)
1086 kind = 123;
1087 break;
1088 case 30:
1089 if ((0x100000001000L & l) != 0L)
1090 jjstateSet[jjnewStateCnt++] = 29;
1091 break;
1092 case 34:
1093 if ((0x20100000201000L & l) != 0L && kind > 125)
1094 kind = 125;
1095 break;
1096 case 36:
1097 if ((0x20000000200000L & l) != 0L && kind > 126)
1098 kind = 126;
1099 break;
1100 case 38:
1101 if ((0x100000001000L & l) != 0L && kind > 127)
1102 kind = 127;
1103 break;
1104 case 39:
1105 if ((0x20000000200000L & l) != 0L)
1106 jjstateSet[jjnewStateCnt++] = 38;
1107 break;
1108 case 40:
1109 if ((0x20000000200000L & l) != 0L && kind > 127)
1110 kind = 127;
1111 break;
1112 case 41:
1113 if ((0x100000001000L & l) != 0L)
1114 jjstateSet[jjnewStateCnt++] = 40;
1115 break;
1116 case 43:
1117 if ((0x100000001000000L & l) != 0L)
1118 jjCheckNAdd(44);
1119 break;
1120 case 44:
1121 if ((0x7e0000007eL & l) == 0L)
1122 break;
1123 if (kind > 128)
1124 kind = 128;
1125 jjCheckNAdd(44);
1126 break;
1127 case 45:
1128 if ((0x100000001000000L & l) != 0L)
1129 jjCheckNAdd(46);
1130 break;
1131 case 46:
1132 if ((0x7e0000007eL & l) == 0L)
1133 break;
1134 if (kind > 129)
1135 kind = 129;
1136 jjCheckNAddTwoStates(46, 47);
1137 break;
1138 case 47:
1139 if ((0x20100000201000L & l) != 0L && kind > 129)
1140 kind = 129;
1141 break;
1142 case 48:
1143 if ((0x100000001000000L & l) != 0L)
1144 jjCheckNAdd(49);
1145 break;
1146 case 49:
1147 if ((0x7e0000007eL & l) != 0L)
1148 jjCheckNAddTwoStates(49, 50);
1149 break;
1150 case 50:
1151 if ((0x20000000200000L & l) != 0L && kind > 130)
1152 kind = 130;
1153 break;
1154 case 51:
1155 if ((0x100000001000000L & l) != 0L)
1156 jjCheckNAdd(52);
1157 break;
1158 case 52:
1159 if ((0x7e0000007eL & l) != 0L)
1160 jjCheckNAddStates(45, 47);
1161 break;
1162 case 53:
1163 if ((0x100000001000L & l) != 0L && kind > 131)
1164 kind = 131;
1165 break;
1166 case 54:
1167 if ((0x20000000200000L & l) != 0L)
1168 jjstateSet[jjnewStateCnt++] = 53;
1169 break;
1170 case 55:
1171 if ((0x20000000200000L & l) != 0L && kind > 131)
1172 kind = 131;
1173 break;
1174 case 56:
1175 if ((0x100000001000L & l) != 0L)
1176 jjstateSet[jjnewStateCnt++] = 55;
1177 break;
1178 case 63:
1179 if ((0x2000000020L & l) != 0L)
1180 jjAddStates(57, 58);
1181 break;
1182 case 66:
1183 if ((0x104000001040L & l) != 0L && kind > 133)
1184 kind = 133;
1185 break;
1186 case 67:
1187 if (curChar == 76)
1188 jjAddStates(51, 52);
1189 break;
1190 default : break;
1191 }
1192 } while(i != startsAt);
1193 }
1194 else
1195 {
1196 int hiByte = (int)(curChar >> 8);
1197 int i1 = hiByte >> 6;
1198 long l1 = 1L << (hiByte & 077);
1199 int i2 = (curChar & 0xff) >> 6;
1200 long l2 = 1L << (curChar & 077);
1201 do
1202 {
1203 switch(jjstateSet[--i])
1204 {
1205 case 7:
1206 case 9:
1207 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1208 jjCheckNAddStates(9, 11);
1209 break;
1210 case 12:
1211 case 14:
1212 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1213 jjCheckNAddStates(6, 8);
1214 break;
1215 default : break;
1216 }
1217 } while(i != startsAt);
1218 }
1219 if (kind != 0x7fffffff)
1220 {
1221 jjmatchedKind = kind;
1222 jjmatchedPos = curPos;
1223 kind = 0x7fffffff;
1224 }
1225 ++curPos;
1226 if ((i = jjnewStateCnt) == (startsAt = 68 - (jjnewStateCnt = startsAt)))
1227 return curPos;
1228 try { curChar = input_stream.readChar(); }
1229 catch(java.io.IOException e) { return curPos; }
1230 }
1231 }
1232 private int jjMoveStringLiteralDfa0_1()
1233 {
1234 switch(curChar)
1235 {
1236 case 10:
1237 return jjStopAtPos(0, 9);
1238 default :
1239 return 1;
1240 }
1241 }
1242 private int jjMoveStringLiteralDfa0_4()
1243 {
1244 switch(curChar)
1245 {
1246 case 10:
1247 return jjStopAtPos(0, 14);
1248 case 47:
1249 return jjMoveStringLiteralDfa1_4(0x18000L);
1250 case 92:
1251 return jjMoveStringLiteralDfa1_4(0x60000L);
1252 default :
1253 return 1;
1254 }
1255 }
1256 private int jjMoveStringLiteralDfa1_4(long active0)
1257 {
1258 try { curChar = input_stream.readChar(); }
1259 catch(java.io.IOException e) {
1260 return 1;
1261 }
1262 switch(curChar)
1263 {
1264 case 10:
1265 if ((active0 & 0x20000L) != 0L)
1266 return jjStopAtPos(1, 17);
1267 break;
1268 case 13:
1269 return jjMoveStringLiteralDfa2_4(active0, 0x40000L);
1270 case 42:
1271 if ((active0 & 0x8000L) != 0L)
1272 return jjStopAtPos(1, 15);
1273 break;
1274 case 47:
1275 if ((active0 & 0x10000L) != 0L)
1276 return jjStopAtPos(1, 16);
1277 break;
1278 default :
1279 return 2;
1280 }
1281 return 2;
1282 }
1283 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
1284 {
1285 if (((active0 &= old0)) == 0L)
1286 return 2;
1287 try { curChar = input_stream.readChar(); }
1288 catch(java.io.IOException e) {
1289 return 2;
1290 }
1291 switch(curChar)
1292 {
1293 case 10:
1294 if ((active0 & 0x40000L) != 0L)
1295 return jjStopAtPos(2, 18);
1296 break;
1297 default :
1298 return 3;
1299 }
1300 return 3;
1301 }
1302 private int jjMoveStringLiteralDfa0_3()
1303 {
1304 switch(curChar)
1305 {
1306 case 42:
1307 return jjMoveStringLiteralDfa1_3(0x2000L);
1308 default :
1309 return 1;
1310 }
1311 }
1312 private int jjMoveStringLiteralDfa1_3(long active0)
1313 {
1314 try { curChar = input_stream.readChar(); }
1315 catch(java.io.IOException e) {
1316 return 1;
1317 }
1318 switch(curChar)
1319 {
1320 case 47:
1321 if ((active0 & 0x2000L) != 0L)
1322 return jjStopAtPos(1, 13);
1323 break;
1324 default :
1325 return 2;
1326 }
1327 return 2;
1328 }
1329 private int jjMoveStringLiteralDfa0_2()
1330 {
1331 switch(curChar)
1332 {
1333 case 42:
1334 return jjMoveStringLiteralDfa1_2(0x800L);
1335 default :
1336 return 1;
1337 }
1338 }
1339 private int jjMoveStringLiteralDfa1_2(long active0)
1340 {
1341 try { curChar = input_stream.readChar(); }
1342 catch(java.io.IOException e) {
1343 return 1;
1344 }
1345 switch(curChar)
1346 {
1347 case 47:
1348 if ((active0 & 0x800L) != 0L)
1349 return jjStopAtPos(1, 11);
1350 break;
1351 default :
1352 return 2;
1353 }
1354 return 2;
1355 }
1356 static final int[] jjnextStates = {
1357 58, 59, 61, 0, 62, 63, 12, 13, 15, 7, 8, 10, 32, 33, 34, 35,
1358 36, 37, 39, 41, 43, 45, 48, 51, 21, 22, 23, 24, 25, 26, 28, 30,
1359 1, 2, 5, 26, 28, 30, 37, 39, 41, 46, 47, 49, 50, 52, 54, 56,
1360 60, 2, 5, 6, 11, 3, 4, 14, 17, 64, 65,
1361 };
1362 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1363 {
1364 switch(hiByte)
1365 {
1366 case 0:
1367 return ((jjbitVec2[i2] & l2) != 0L);
1368 default :
1369 if ((jjbitVec0[i1] & l1) != 0L)
1370 return true;
1371 return false;
1372 }
1373 }
1374
1375
1376 public static final String[] jjstrLiteralImages = {
1377 "", null, null, null, null, null, null, null, null, null, null, null, null,
1378 null, null, null, null, null, null, null, "\173", "\175", "\133", "\135", "\50",
1379 "\51", "\72\72", "\72", "\73", "\54", "\77", "\56\56\56", "\75", "\52\75", "\57\75",
1380 "\45\75", "\53\75", "\55\75", "\74\74\75", "\76\76\75", "\46\75", "\136\75", "\174\75",
1381 "\174\174", "\46\46", "\174", "\136", "\46", "\75\75", "\41\75", "\74", "\76", "\74\75",
1382 "\76\75", "\74\74", "\76\76", "\53", "\55", "\52", "\57", "\45", "\53\53", "\55\55",
1383 "\176", "\41", "\56", "\55\76", "\56\52", "\55\76\52", "\141\165\164\157",
1384 "\142\162\145\141\153", "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162",
1385 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
1386 "\144\145\154\145\164\145", "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
1387 "\145\156\165\155", "\145\170\164\145\162\156", "\146\154\157\141\164", "\146\157\162",
1388 "\146\162\151\145\156\144", "\147\157\164\157", "\151\146", "\151\156\154\151\156\145", "\151\156\164",
1389 "\154\157\156\147", "\156\145\167", "\160\162\151\166\141\164\145",
1390 "\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",
1391 "\162\145\147\151\163\164\145\162", "\162\145\164\165\162\156", "\163\150\157\162\164",
1392 "\163\151\147\156\145\144", "\163\151\172\145\157\146", "\163\164\141\164\151\143",
1393 "\163\164\162\165\143\164", "\143\154\141\163\163", "\163\167\151\164\143\150",
1394 "\164\145\155\160\154\141\164\145", "\164\150\151\163", "\164\162\171", "\164\171\160\145\144\145\146",
1395 "\165\156\151\157\156", "\165\156\163\151\147\156\145\144", "\166\151\162\164\165\141\154",
1396 "\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\151\154\145",
1397 "\157\160\145\162\141\164\157\162", "\164\162\165\145", "\146\141\154\163\145", "\164\150\162\157\167", "\100",
1398 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1399 null, null, "\146\151\156\141\154\154\171", null, };
1400
1401
1402 public static final String[] lexStateNames = {
1403 "DEFAULT",
1404 "IN_LINE_COMMENT",
1405 "IN_COMMENT",
1406 "IN_PREPROCESSOR_OUTPUT_COMMENT",
1407 "PREPROCESSOR_OUTPUT",
1408 };
1409
1410
1411 public static final int[] jjnewLexState = {
1412 -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, 1, -1, -1, -1, -1, -1, -1, -1, -1,
1413 -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,
1414 -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,
1415 -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,
1416 -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,
1417 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1418 };
1419 static final long[] jjtoToken = {
1420 0xfffffffffff00001L, 0xffffffffffffffffL, 0x3ffL,
1421 };
1422 static final long[] jjtoSkip = {
1423 0x1ebfeL, 0x0L, 0x0L,
1424 };
1425 static final long[] jjtoMore = {
1426 0xe1400L, 0x0L, 0x0L,
1427 };
1428 protected CharStream input_stream;
1429 private final int[] jjrounds = new int[68];
1430 private final int[] jjstateSet = new int[136];
1431 protected char curChar;
1432
1433 public CppParserTokenManager(CharStream stream){
1434 input_stream = stream;
1435 }
1436
1437
1438 public CppParserTokenManager(CharStream stream, int lexState){
1439 this(stream);
1440 SwitchTo(lexState);
1441 }
1442
1443
1444 public void ReInit(CharStream stream)
1445 {
1446 jjmatchedPos = jjnewStateCnt = 0;
1447 curLexState = defaultLexState;
1448 input_stream = stream;
1449 ReInitRounds();
1450 }
1451 private void ReInitRounds()
1452 {
1453 int i;
1454 jjround = 0x80000001;
1455 for (i = 68; i-- > 0;)
1456 jjrounds[i] = 0x80000000;
1457 }
1458
1459
1460 public void ReInit(CharStream stream, int lexState)
1461 {
1462 ReInit(stream);
1463 SwitchTo(lexState);
1464 }
1465
1466
1467 public void SwitchTo(int lexState)
1468 {
1469 if (lexState >= 5 || lexState < 0)
1470 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1471 else
1472 curLexState = lexState;
1473 }
1474
1475 protected Token jjFillToken()
1476 {
1477 final Token t;
1478 final String curTokenImage;
1479 final int beginLine;
1480 final int endLine;
1481 final int beginColumn;
1482 final int endColumn;
1483 String im = jjstrLiteralImages[jjmatchedKind];
1484 curTokenImage = (im == null) ? input_stream.GetImage() : im;
1485 beginLine = input_stream.getBeginLine();
1486 beginColumn = input_stream.getBeginColumn();
1487 endLine = input_stream.getEndLine();
1488 endColumn = input_stream.getEndColumn();
1489 t = Token.newToken(jjmatchedKind, curTokenImage);
1490
1491 t.beginLine = beginLine;
1492 t.endLine = endLine;
1493 t.beginColumn = beginColumn;
1494 t.endColumn = endColumn;
1495
1496 return t;
1497 }
1498
1499 int curLexState = 0;
1500 int defaultLexState = 0;
1501 int jjnewStateCnt;
1502 int jjround;
1503 int jjmatchedPos;
1504 int jjmatchedKind;
1505
1506
1507 public Token getNextToken()
1508 {
1509 Token matchedToken;
1510 int curPos = 0;
1511
1512 EOFLoop :
1513 for (;;)
1514 {
1515 try
1516 {
1517 curChar = input_stream.BeginToken();
1518 }
1519 catch(java.io.IOException e)
1520 {
1521 jjmatchedKind = 0;
1522 matchedToken = jjFillToken();
1523 return matchedToken;
1524 }
1525
1526 for (;;)
1527 {
1528 switch(curLexState)
1529 {
1530 case 0:
1531 try { input_stream.backup(0);
1532 while (curChar <= 32 && (0x100001600L & (1L << curChar)) != 0L)
1533 curChar = input_stream.BeginToken();
1534 }
1535 catch (java.io.IOException e1) { continue EOFLoop; }
1536 jjmatchedKind = 0x7fffffff;
1537 jjmatchedPos = 0;
1538 curPos = jjMoveStringLiteralDfa0_0();
1539 break;
1540 case 1:
1541 jjmatchedKind = 0x7fffffff;
1542 jjmatchedPos = 0;
1543 curPos = jjMoveStringLiteralDfa0_1();
1544 if (jjmatchedPos == 0 && jjmatchedKind > 10)
1545 {
1546 jjmatchedKind = 10;
1547 }
1548 break;
1549 case 2:
1550 jjmatchedKind = 0x7fffffff;
1551 jjmatchedPos = 0;
1552 curPos = jjMoveStringLiteralDfa0_2();
1553 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1554 {
1555 jjmatchedKind = 12;
1556 }
1557 break;
1558 case 3:
1559 jjmatchedKind = 0x7fffffff;
1560 jjmatchedPos = 0;
1561 curPos = jjMoveStringLiteralDfa0_3();
1562 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1563 {
1564 jjmatchedKind = 12;
1565 }
1566 break;
1567 case 4:
1568 jjmatchedKind = 0x7fffffff;
1569 jjmatchedPos = 0;
1570 curPos = jjMoveStringLiteralDfa0_4();
1571 if (jjmatchedPos == 0 && jjmatchedKind > 19)
1572 {
1573 jjmatchedKind = 19;
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 private void jjCheckNAdd(int state)
1629 {
1630 if (jjrounds[state] != jjround)
1631 {
1632 jjstateSet[jjnewStateCnt++] = state;
1633 jjrounds[state] = jjround;
1634 }
1635 }
1636 private void jjAddStates(int start, int end)
1637 {
1638 do {
1639 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1640 } while (start++ != end);
1641 }
1642 private void jjCheckNAddTwoStates(int state1, int state2)
1643 {
1644 jjCheckNAdd(state1);
1645 jjCheckNAdd(state2);
1646 }
1647
1648 private void jjCheckNAddStates(int start, int end)
1649 {
1650 do {
1651 jjCheckNAdd(jjnextStates[start]);
1652 } while (start++ != end);
1653 }
1654
1655 }