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