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