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