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