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