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