|
1
2 package bsh;
3 import java.io.*;
4 import java.util.Vector  ;
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, long active2)
11 {
12 switch (pos)
13 {
14 case 0:
15 if ((active1 & 0x200020000000000L) != 0L)
16 return 56;
17 if ((active0 & 0x3eL) != 0L)
18 return 0;
19 if ((active1 & 0x10000L) != 0L)
20 return 11;
21 if ((active0 & 0xffffffffffffc00L) != 0L)
22 {
23 jjmatchedKind = 69;
24 return 35;
25 }
26 return -1;
27 case 1:
28 if ((active0 & 0x100600000L) != 0L)
29 return 35;
30 if ((active0 & 0xffffffeff9ffc00L) != 0L)
31 {
32 if (jjmatchedPos != 1)
33 {
34 jjmatchedKind = 69;
35 jjmatchedPos = 1;
36 }
37 return 35;
38 }
39 return -1;
40 case 2:
41 if ((active0 & 0xefffecebfdffc00L) != 0L)
42 {
43 if (jjmatchedPos != 2)
44 {
45 jjmatchedKind = 69;
46 jjmatchedPos = 2;
47 }
48 return 35;
49 }
50 if ((active0 & 0x100013040000000L) != 0L)
51 return 35;
52 return -1;
53 case 3:
54 if ((active0 & 0xc7ffcae3e5d3c00L) != 0L)
55 {
56 if (jjmatchedPos != 3)
57 {
58 jjmatchedKind = 69;
59 jjmatchedPos = 3;
60 }
61 return 35;
62 }
63 if ((active0 & 0x28002408182c000L) != 0L)
64 return 35;
65 return -1;
66 case 4:
67 if ((active0 & 0x86080003c053000L) != 0L)
68 return 35;
69 if ((active0 & 0x41f7cae02580c00L) != 0L)
70 {
71 if (jjmatchedPos != 4)
72 {
73 jjmatchedKind = 69;
74 jjmatchedPos = 4;
75 }
76 return 35;
77 }
78 return -1;
79 case 5:
80 if ((active0 & 0x41a1c2a12180c00L) != 0L)
81 {
82 jjmatchedKind = 69;
83 jjmatchedPos = 5;
84 return 35;
85 }
86 if ((active0 & 0x45608400400000L) != 0L)
87 return 35;
88 return -1;
89 case 6:
90 if ((active0 & 0x41a102a00080400L) != 0L)
91 {
92 jjmatchedKind = 69;
93 jjmatchedPos = 6;
94 return 35;
95 }
96 if ((active0 & 0xc0012100800L) != 0L)
97 return 35;
98 return -1;
99 case 7:
100 if ((active0 & 0x402000000080400L) != 0L)
101 return 35;
102 if ((active0 & 0x18102a00000000L) != 0L)
103 {
104 jjmatchedKind = 69;
105 jjmatchedPos = 7;
106 return 35;
107 }
108 return -1;
109 case 8:
110 if ((active0 & 0x8000a00000000L) != 0L)
111 {
112 jjmatchedKind = 69;
113 jjmatchedPos = 8;
114 return 35;
115 }
116 if ((active0 & 0x10102000000000L) != 0L)
117 return 35;
118 return -1;
119 case 9:
120 if ((active0 & 0x8000000000000L) != 0L)
121 {
122 jjmatchedKind = 69;
123 jjmatchedPos = 9;
124 return 35;
125 }
126 if ((active0 & 0xa00000000L) != 0L)
127 return 35;
128 return -1;
129 case 10:
130 if ((active0 & 0x8000000000000L) != 0L)
131 {
132 if (jjmatchedPos != 10)
133 {
134 jjmatchedKind = 69;
135 jjmatchedPos = 10;
136 }
137 return 35;
138 }
139 return -1;
140 case 11:
141 if ((active0 & 0x8000000000000L) != 0L)
142 return 35;
143 return -1;
144 default :
145 return -1;
146 }
147 }
148 private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
149 {
150 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
151 }
152 private final int jjStopAtPos(int pos, int kind)
153 {
154 jjmatchedKind = kind;
155 jjmatchedPos = pos;
156 return pos + 1;
157 }
158 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
159 {
160 jjmatchedKind = kind;
161 jjmatchedPos = pos;
162 try { curChar = input_stream.readChar(); }
163 catch(java.io.IOException e) { return pos + 1; }
164 return jjMoveNfa_0(state, pos + 1);
165 }
166 private final int jjMoveStringLiteralDfa0_0()
167 {
168 switch(curChar)
169 {
170 case 9:
171 return jjStartNfaWithStates_0(0, 2, 0);
172 case 10:
173 return jjStartNfaWithStates_0(0, 5, 0);
174 case 12:
175 return jjStartNfaWithStates_0(0, 4, 0);
176 case 13:
177 return jjStartNfaWithStates_0(0, 3, 0);
178 case 32:
179 return jjStartNfaWithStates_0(0, 1, 0);
180 case 33:
181 jjmatchedKind = 86;
182 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L, 0x0L);
183 case 37:
184 jjmatchedKind = 111;
185 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000000L, 0x0L);
186 case 38:
187 jjmatchedKind = 106;
188 return jjMoveStringLiteralDfa1_0(0x0L, 0x400000400000000L, 0x0L);
189 case 40:
190 return jjStopAtPos(0, 72);
191 case 41:
192 return jjStopAtPos(0, 73);
193 case 42:
194 jjmatchedKind = 104;
195 return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L, 0x0L);
196 case 43:
197 jjmatchedKind = 102;
198 return jjMoveStringLiteralDfa1_0(0x0L, 0x40001000000000L, 0x0L);
199 case 44:
200 return jjStopAtPos(0, 79);
201 case 45:
202 jjmatchedKind = 103;
203 return jjMoveStringLiteralDfa1_0(0x0L, 0x80002000000000L, 0x0L);
204 case 46:
205 return jjStartNfaWithStates_0(0, 80, 11);
206 case 47:
207 jjmatchedKind = 105;
208 return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000000L, 0x0L);
209 case 58:
210 return jjStopAtPos(0, 89);
211 case 59:
212 return jjStopAtPos(0, 78);
213 case 60:
214 jjmatchedKind = 84;
215 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000008000000L, 0x1L);
216 case 61:
217 jjmatchedKind = 81;
218 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L, 0x0L);
219 case 62:
220 jjmatchedKind = 82;
221 return jjMoveStringLiteralDfa1_0(0x0L, 0x14000020000000L, 0x14L);
222 case 63:
223 return jjStopAtPos(0, 88);
224 case 64:
225 return jjMoveStringLiteralDfa1_0(0x0L, 0x282a280a50280000L, 0x2aL);
226 case 91:
227 return jjStopAtPos(0, 76);
228 case 93:
229 return jjStopAtPos(0, 77);
230 case 94:
231 jjmatchedKind = 110;
232 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000000L, 0x0L);
233 case 97:
234 return jjMoveStringLiteralDfa1_0(0x400L, 0x0L, 0x0L);
235 case 98:
236 return jjMoveStringLiteralDfa1_0(0x5800L, 0x0L, 0x0L);
237 case 99:
238 return jjMoveStringLiteralDfa1_0(0xfa000L, 0x0L, 0x0L);
239 case 100:
240 return jjMoveStringLiteralDfa1_0(0x700000L, 0x0L, 0x0L);
241 case 101:
242 return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L, 0x0L);
243 case 102:
244 return jjMoveStringLiteralDfa1_0(0x7c000000L, 0x0L, 0x0L);
245 case 103:
246 return jjMoveStringLiteralDfa1_0(0x80000000L, 0x0L, 0x0L);
247 case 105:
248 return jjMoveStringLiteralDfa1_0(0x3f00000000L, 0x0L, 0x0L);
249 case 108:
250 return jjMoveStringLiteralDfa1_0(0x4000000000L, 0x0L, 0x0L);
251 case 110:
252 return jjMoveStringLiteralDfa1_0(0x38000000000L, 0x0L, 0x0L);
253 case 112:
254 return jjMoveStringLiteralDfa1_0(0x3c0000000000L, 0x0L, 0x0L);
255 case 114:
256 return jjMoveStringLiteralDfa1_0(0x400000000000L, 0x0L, 0x0L);
257 case 115:
258 return jjMoveStringLiteralDfa1_0(0xf800000000000L, 0x0L, 0x0L);
259 case 116:
260 return jjMoveStringLiteralDfa1_0(0x1f0000000000000L, 0x0L, 0x0L);
261 case 118:
262 return jjMoveStringLiteralDfa1_0(0x600000000000000L, 0x0L, 0x0L);
263 case 119:
264 return jjMoveStringLiteralDfa1_0(0x800000000000000L, 0x0L, 0x0L);
265 case 123:
266 return jjStopAtPos(0, 74);
267 case 124:
268 jjmatchedKind = 108;
269 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000100000000L, 0x0L);
270 case 125:
271 return jjStopAtPos(0, 75);
272 case 126:
273 return jjStopAtPos(0, 87);
274 default :
275 return jjMoveNfa_0(6, 0);
276 }
277 }
278 private final int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2)
279 {
280 try { curChar = input_stream.readChar(); }
281 catch(java.io.IOException e) {
282 jjStopStringLiteralDfa_0(0, active0, active1, active2);
283 return 1;
284 }
285 switch(curChar)
286 {
287 case 38:
288 if ((active1 & 0x400000000L) != 0L)
289 return jjStopAtPos(1, 98);
290 break;
291 case 43:
292 if ((active1 & 0x1000000000L) != 0L)
293 return jjStopAtPos(1, 100);
294 break;
295 case 45:
296 if ((active1 & 0x2000000000L) != 0L)
297 return jjStopAtPos(1, 101);
298 break;
299 case 60:
300 if ((active1 & 0x1000000000000L) != 0L)
301 {
302 jjmatchedKind = 112;
303 jjmatchedPos = 1;
304 }
305 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x1L);
306 case 61:
307 if ((active1 & 0x4000000L) != 0L)
308 return jjStopAtPos(1, 90);
309 else if ((active1 & 0x8000000L) != 0L)
310 return jjStopAtPos(1, 91);
311 else if ((active1 & 0x20000000L) != 0L)
312 return jjStopAtPos(1, 93);
313 else if ((active1 & 0x80000000L) != 0L)
314 return jjStopAtPos(1, 95);
315 else if ((active1 & 0x40000000000000L) != 0L)
316 return jjStopAtPos(1, 118);
317 else if ((active1 & 0x80000000000000L) != 0L)
318 return jjStopAtPos(1, 119);
319 else if ((active1 & 0x100000000000000L) != 0L)
320 return jjStopAtPos(1, 120);
321 else if ((active1 & 0x200000000000000L) != 0L)
322 return jjStopAtPos(1, 121);
323 else if ((active1 & 0x400000000000000L) != 0L)
324 return jjStopAtPos(1, 122);
325 else if ((active1 & 0x1000000000000000L) != 0L)
326 return jjStopAtPos(1, 124);
327 else if ((active1 & 0x4000000000000000L) != 0L)
328 return jjStopAtPos(1, 126);
329 else if ((active1 & 0x8000000000000000L) != 0L)
330 return jjStopAtPos(1, 127);
331 break;
332 case 62:
333 if ((active1 & 0x4000000000000L) != 0L)
334 {
335 jjmatchedKind = 114;
336 jjmatchedPos = 1;
337 }
338 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10000000000000L, active2, 0x14L);
339 case 97:
340 return jjMoveStringLiteralDfa2_0(active0, 0x48004018000L, active1, 0x800000800000000L, active2, 0L);
341 case 98:
342 return jjMoveStringLiteralDfa2_0(active0, 0x400L, active1, 0x280000000000L, active2, 0L);
343 case 101:
344 return jjMoveStringLiteralDfa2_0(active0, 0x410000100000L, active1, 0L, active2, 0L);
345 case 102:
346 if ((active0 & 0x100000000L) != 0L)
347 return jjStartNfaWithStates_0(1, 32, 35);
348 break;
349 case 103:
350 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40080000L, active2, 0L);
351 case 104:
352 return jjMoveStringLiteralDfa2_0(active0, 0x860800000020000L, active1, 0L, active2, 0L);
353 case 105:
354 return jjMoveStringLiteralDfa2_0(active0, 0x18000000L, active1, 0L, active2, 0L);
355 case 108:
356 return jjMoveStringLiteralDfa2_0(active0, 0x20802000L, active1, 0x2000010200000L, active2, 0x2L);
357 case 109:
358 return jjMoveStringLiteralDfa2_0(active0, 0x600000000L, active1, 0L, active2, 0L);
359 case 110:
360 return jjMoveStringLiteralDfa2_0(active0, 0x3801000000L, active1, 0L, active2, 0L);
361 case 111:
362 if ((active0 & 0x200000L) != 0L)
363 {
364 jjmatchedKind = 21;
365 jjmatchedPos = 1;
366 }
367 return jjMoveStringLiteralDfa2_0(active0, 0x6000040c04c0800L, active1, 0x2000000200000000L, active2, 0L);
368 case 114:
369 return jjMoveStringLiteralDfa2_0(active0, 0x190180000001000L, active1, 0x28000000000000L, active2, 0x28L);
370 case 116:
371 return jjMoveStringLiteralDfa2_0(active0, 0x3000000000000L, active1, 0L, active2, 0L);
372 case 117:
373 return jjMoveStringLiteralDfa2_0(active0, 0x220000000000L, active1, 0L, active2, 0L);
374 case 119:
375 return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L, active1, 0L, active2, 0L);
376 case 120:
377 return jjMoveStringLiteralDfa2_0(active0, 0x2000000L, active1, 0L, active2, 0L);
378 case 121:
379 return jjMoveStringLiteralDfa2_0(active0, 0x8000000004000L, active1, 0L, active2, 0L);
380 case 124:
381 if ((active1 & 0x100000000L) != 0L)
382 return jjStopAtPos(1, 96);
383 break;
384 default :
385 break;
386 }
387 return jjStartNfa_0(0, active0, active1, active2);
388 }
389 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2)
390 {
391 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
392 return jjStartNfa_0(0, old0, old1, old2);
393 try { curChar = input_stream.readChar(); }
394 catch(java.io.IOException e) {
395 jjStopStringLiteralDfa_0(1, active0, active1, active2);
396 return 2;
397 }
398 switch(curChar)
399 {
400 case 61:
401 if ((active2 & 0x1L) != 0L)
402 return jjStopAtPos(2, 128);
403 else if ((active2 & 0x4L) != 0L)
404 return jjStopAtPos(2, 130);
405 break;
406 case 62:
407 if ((active1 & 0x10000000000000L) != 0L)
408 {
409 jjmatchedKind = 116;
410 jjmatchedPos = 2;
411 }
412 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0x10L);
413 case 97:
414 return jjMoveStringLiteralDfa3_0(active0, 0x11000000022000L, active1, 0L, active2, 0L);
415 case 98:
416 return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0L, active2, 0L);
417 case 99:
418 return jjMoveStringLiteralDfa3_0(active0, 0x40000000000L, active1, 0L, active2, 0L);
419 case 101:
420 return jjMoveStringLiteralDfa3_0(active0, 0x1000L, active1, 0x2000000000000L, active2, 0x2L);
421 case 102:
422 return jjMoveStringLiteralDfa3_0(active0, 0x100000L, active1, 0L, active2, 0L);
423 case 105:
424 return jjMoveStringLiteralDfa3_0(active0, 0xa04080000000000L, active1, 0x28280000000000L, active2, 0x28L);
425 case 108:
426 return jjMoveStringLiteralDfa3_0(active0, 0x400020004000000L, active1, 0L, active2, 0L);
427 case 110:
428 return jjMoveStringLiteralDfa3_0(active0, 0x80040180c0000L, active1, 0x800000800000000L, active2, 0L);
429 case 111:
430 return jjMoveStringLiteralDfa3_0(active0, 0x900020000800L, active1, 0L, active2, 0L);
431 case 112:
432 return jjMoveStringLiteralDfa3_0(active0, 0x600000000L, active1, 0L, active2, 0L);
433 case 114:
434 if ((active0 & 0x40000000L) != 0L)
435 return jjStartNfaWithStates_0(2, 30, 35);
436 else if ((active1 & 0x200000000L) != 0L)
437 {
438 jjmatchedKind = 97;
439 jjmatchedPos = 2;
440 }
441 return jjMoveStringLiteralDfa3_0(active0, 0x62000000000000L, active1, 0x2000000000000000L, active2, 0L);
442 case 115:
443 return jjMoveStringLiteralDfa3_0(active0, 0x800808400L, active1, 0L, active2, 0L);
444 case 116:
445 if ((active0 & 0x1000000000L) != 0L)
446 {
447 jjmatchedKind = 36;
448 jjmatchedPos = 2;
449 }
450 else if ((active1 & 0x80000L) != 0L)
451 {
452 jjmatchedKind = 83;
453 jjmatchedPos = 2;
454 }
455 else if ((active1 & 0x200000L) != 0L)
456 {
457 jjmatchedKind = 85;
458 jjmatchedPos = 2;
459 }
460 return jjMoveStringLiteralDfa3_0(active0, 0x40a082014000L, active1, 0x50000000L, active2, 0L);
461 case 117:
462 return jjMoveStringLiteralDfa3_0(active0, 0x80000001400000L, active1, 0L, active2, 0L);
463 case 119:
464 if ((active0 & 0x10000000000L) != 0L)
465 return jjStartNfaWithStates_0(2, 40, 35);
466 break;
467 case 121:
468 if ((active0 & 0x100000000000000L) != 0L)
469 return jjStartNfaWithStates_0(2, 56, 35);
470 break;
471 default :
472 break;
473 }
474 return jjStartNfa_0(1, active0, active1, active2);
475 }
476 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2)
477 {
478 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
479 return jjStartNfa_0(1, old0, old1, old2);
480 try { curChar = input_stream.readChar(); }
481 catch(java.io.IOException e) {
482 jjStopStringLiteralDfa_0(2, active0, active1, active2);
483 return 3;
484 }
485 switch(curChar)
486 {
487 case 61:
488 if ((active2 & 0x10L) != 0L)
489 return jjStopAtPos(3, 132);
490 break;
491 case 95:
492 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x2000000000000000L, active2, 0L);
493 case 97:
494 return jjMoveStringLiteralDfa4_0(active0, 0x400000038101000L, active1, 0L, active2, 0L);
495 case 98:
496 return jjMoveStringLiteralDfa4_0(active0, 0x400000L, active1, 0L, active2, 0L);
497 case 99:
498 return jjMoveStringLiteralDfa4_0(active0, 0x8000000010000L, active1, 0L, active2, 0L);
499 case 100:
500 if ((active0 & 0x200000000000000L) != 0L)
501 return jjStartNfaWithStates_0(3, 57, 35);
502 else if ((active1 & 0x800000000L) != 0L)
503 {
504 jjmatchedKind = 99;
505 jjmatchedPos = 3;
506 }
507 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x800000000000000L, active2, 0L);
508 case 101:
509 if ((active0 & 0x4000L) != 0L)
510 return jjStartNfaWithStates_0(3, 14, 35);
511 else if ((active0 & 0x8000L) != 0L)
512 return jjStartNfaWithStates_0(3, 15, 35);
513 else if ((active0 & 0x800000L) != 0L)
514 return jjStartNfaWithStates_0(3, 23, 35);
515 else if ((active0 & 0x80000000000000L) != 0L)
516 return jjStartNfaWithStates_0(3, 55, 35);
517 return jjMoveStringLiteralDfa4_0(active0, 0x2002000000L, active1, 0x50000000L, active2, 0L);
518 case 102:
519 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x2000000000000L, active2, 0x2L);
520 case 103:
521 if ((active0 & 0x4000000000L) != 0L)
522 return jjStartNfaWithStates_0(3, 38, 35);
523 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x28000000000000L, active2, 0x28L);
524 case 105:
525 return jjMoveStringLiteralDfa4_0(active0, 0x2008000000000L, active1, 0L, active2, 0L);
526 case 107:
527 return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L, active1, 0L, active2, 0L);
528 case 108:
529 if ((active0 & 0x20000000000L) != 0L)
530 return jjStartNfaWithStates_0(3, 41, 35);
531 return jjMoveStringLiteralDfa4_0(active0, 0x800200200000800L, active1, 0L, active2, 0L);
532 case 109:
533 if ((active0 & 0x1000000L) != 0L)
534 return jjStartNfaWithStates_0(3, 24, 35);
535 break;
536 case 110:
537 return jjMoveStringLiteralDfa4_0(active0, 0x10000000000000L, active1, 0L, active2, 0L);
538 case 111:
539 if ((active0 & 0x80000000L) != 0L)
540 return jjStartNfaWithStates_0(3, 31, 35);
541 return jjMoveStringLiteralDfa4_0(active0, 0x60000400000000L, active1, 0L, active2, 0L);
542 case 114:
543 if ((active0 & 0x20000L) != 0L)
544 return jjStartNfaWithStates_0(3, 17, 35);
545 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L, active2, 0L);
546 case 115:
547 return jjMoveStringLiteralDfa4_0(active0, 0x4042000L, active1, 0L, active2, 0L);
548 case 116:
549 return jjMoveStringLiteralDfa4_0(active0, 0x5100800080400L, active1, 0x280000000000L, active2, 0L);
550 case 117:
551 return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L, active2, 0L);
552 case 118:
553 return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0L, active2, 0L);
554 default :
555 break;
556 }
557 return jjStartNfa_0(2, active0, active1, active2);
558 }
559 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1, long old2, long active2)
560 {
561 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
562 return jjStartNfa_0(2, old0, old1, old2);
563 try { curChar = input_stream.readChar(); }
564 catch(java.io.IOException e) {
565 jjStopStringLiteralDfa_0(3, active0, active1, active2);
566 return 4;
567 }
568 switch(curChar)
569 {
570 case 95:
571 return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x800000000000000L, active2, 0L);
572 case 97:
573 return jjMoveStringLiteralDfa5_0(active0, 0xc0800000000L, active1, 0x2000000000000000L, active2, 0L);
574 case 99:
575 return jjMoveStringLiteralDfa5_0(active0, 0x6000000000000L, active1, 0L, active2, 0L);
576 case 101:
577 if ((active0 & 0x4000000L) != 0L)
578 return jjStartNfaWithStates_0(4, 26, 35);
579 else if ((active0 & 0x800000000000000L) != 0L)
580 return jjStartNfaWithStates_0(4, 59, 35);
581 return jjMoveStringLiteralDfa5_0(active0, 0x100200000800L, active1, 0L, active2, 0L);
582 case 104:
583 if ((active0 & 0x10000L) != 0L)
584 return jjStartNfaWithStates_0(4, 16, 35);
585 return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000L, active1, 0x28000000000000L, active2, 0x28L);
586 case 105:
587 return jjMoveStringLiteralDfa5_0(active0, 0x1200000080000L, active1, 0L, active2, 0L);
588 case 107:
589 if ((active0 & 0x1000L) != 0L)
590 return jjStartNfaWithStates_0(4, 12, 35);
591 break;
592 case 108:
593 if ((active0 & 0x8000000L) != 0L)
594 {
595 jjmatchedKind = 27;
596 jjmatchedPos = 4;
597 }
598 return jjMoveStringLiteralDfa5_0(active0, 0x10400000L, active1, 0L, active2, 0L);
599 case 110:
600 return jjMoveStringLiteralDfa5_0(active0, 0x2000000L, active1, 0L, active2, 0L);
601 case 113:
602 if ((active1 & 0x10000000L) != 0L)
603 return jjStopAtPos(4, 92);
604 else if ((active1 & 0x40000000L) != 0L)
605 return jjStopAtPos(4, 94);
606 break;
607 case 114:
608 return jjMoveStringLiteralDfa5_0(active0, 0x402400000400L, active1, 0L, active2, 0L);
609 case 115:
610 if ((active0 & 0x2000L) != 0L)
611 return jjStartNfaWithStates_0(4, 13, 35);
612 return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L, active1, 0L, active2, 0L);
613 case 116:
614 if ((active0 & 0x40000L) != 0L)
615 return jjStartNfaWithStates_0(4, 18, 35);
616 else if ((active0 & 0x20000000L) != 0L)
617 return jjStartNfaWithStates_0(4, 29, 35);
618 else if ((active0 & 0x800000000000L) != 0L)
619 return jjStartNfaWithStates_0(4, 47, 35);
620 return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0x2000000000000L, active2, 0x2L);
621 case 117:
622 return jjMoveStringLiteralDfa5_0(active0, 0x100000L, active1, 0L, active2, 0L);
623 case 118:
624 return jjMoveStringLiteralDfa5_0(active0, 0x8000000000L, active1, 0L, active2, 0L);
625 case 119:
626 if ((active0 & 0x20000000000000L) != 0L)
627 {
628 jjmatchedKind = 53;
629 jjmatchedPos = 4;
630 }
631 return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0x280000000000L, active2, 0L);
632 default :
633 break;
634 }
635 return jjStartNfa_0(3, active0, active1, active2);
636 }
637 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1, long old2, long active2)
638 {
639 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
640 return jjStartNfa_0(3, old0, old1, old2);
641 try { curChar = input_stream.readChar(); }
642 catch(java.io.IOException e) {
643 jjStopStringLiteralDfa_0(4, active0, active1, active2);
644 return 5;
645 }
646 switch(curChar)
647 {
648 case 95:
649 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x2000000000000L, active2, 0x2L);
650 case 97:
651 return jjMoveStringLiteralDfa6_0(active0, 0xc00L, active1, 0x800000000000000L, active2, 0L);
652 case 99:
653 if ((active0 & 0x200000000000L) != 0L)
654 return jjStartNfaWithStates_0(5, 45, 35);
655 else if ((active0 & 0x1000000000000L) != 0L)
656 return jjStartNfaWithStates_0(5, 48, 35);
657 return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0L, active2, 0L);
658 case 100:
659 return jjMoveStringLiteralDfa6_0(active0, 0x2000000L, active1, 0L, active2, 0L);
660 case 101:
661 if ((active0 & 0x400000L) != 0L)
662 return jjStartNfaWithStates_0(5, 22, 35);
663 else if ((active0 & 0x8000000000L) != 0L)
664 return jjStartNfaWithStates_0(5, 39, 35);
665 break;
666 case 102:
667 return jjMoveStringLiteralDfa6_0(active0, 0x2000000000L, active1, 0L, active2, 0L);
668 case 103:
669 return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L, active1, 0L, active2, 0L);
670 case 104:
671 if ((active0 & 0x4000000000000L) != 0L)
672 return jjStartNfaWithStates_0(5, 50, 35);
673 break;
674 case 105:
675 return jjMoveStringLiteralDfa6_0(active0, 0x410000000000000L, active1, 0x280000000000L, active2, 0L);
676 case 108:
677 return jjMoveStringLiteralDfa6_0(active0, 0x10100000L, active1, 0L, active2, 0L);
678 case 109:
679 return jjMoveStringLiteralDfa6_0(active0, 0x200000000L, active1, 0L, active2, 0L);
680 case 110:
681 if ((active0 & 0x400000000000L) != 0L)
682 return jjStartNfaWithStates_0(5, 46, 35);
683 return jjMoveStringLiteralDfa6_0(active0, 0x800080000L, active1, 0L, active2, 0L);
684 case 114:
685 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000L, active1, 0L, active2, 0L);
686 case 115:
687 if ((active0 & 0x40000000000000L) != 0L)
688 return jjStartNfaWithStates_0(5, 54, 35);
689 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x2000000000000000L, active2, 0L);
690 case 116:
691 if ((active0 & 0x400000000L) != 0L)
692 return jjStartNfaWithStates_0(5, 34, 35);
693 return jjMoveStringLiteralDfa6_0(active0, 0x2080000000000L, active1, 0x28000000000000L, active2, 0x28L);
694 default :
695 break;
696 }
697 return jjStartNfa_0(4, active0, active1, active2);
698 }
699 private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1, long old2, long active2)
700 {
701 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
702 return jjStartNfa_0(4, old0, old1, old2);
703 try { curChar = input_stream.readChar(); }
704 catch(java.io.IOException e) {
705 jjStopStringLiteralDfa_0(5, active0, active1, active2);
706 return 6;
707 }
708 switch(curChar)
709 {
710 case 95:
711 return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x28000000000000L, active2, 0x28L);
712 case 97:
713 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000L, active1, 0L, active2, 0L);
714 case 99:
715 return jjMoveStringLiteralDfa7_0(active0, 0x800000400L, active1, 0L, active2, 0L);
716 case 101:
717 if ((active0 & 0x40000000000L) != 0L)
718 return jjStartNfaWithStates_0(6, 42, 35);
719 else if ((active0 & 0x80000000000L) != 0L)
720 return jjStartNfaWithStates_0(6, 43, 35);
721 return jjMoveStringLiteralDfa7_0(active0, 0x10000200000000L, active1, 0L, active2, 0L);
722 case 102:
723 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000L, active1, 0L, active2, 0L);
724 case 108:
725 return jjMoveStringLiteralDfa7_0(active0, 0x400000000000000L, active1, 0L, active2, 0L);
726 case 110:
727 if ((active0 & 0x800L) != 0L)
728 return jjStartNfaWithStates_0(6, 11, 35);
729 break;
730 case 111:
731 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L, active1, 0L, active2, 0L);
732 case 115:
733 if ((active0 & 0x2000000L) != 0L)
734 return jjStartNfaWithStates_0(6, 25, 35);
735 return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x2802280000000000L, active2, 0x2L);
736 case 116:
737 if ((active0 & 0x100000L) != 0L)
738 return jjStartNfaWithStates_0(6, 20, 35);
739 return jjMoveStringLiteralDfa7_0(active0, 0x100000000000L, active1, 0L, active2, 0L);
740 case 117:
741 return jjMoveStringLiteralDfa7_0(active0, 0x80000L, active1, 0L, active2, 0L);
742 case 121:
743 if ((active0 & 0x10000000L) != 0L)
744 return jjStartNfaWithStates_0(6, 28, 35);
745 break;
746 default :
747 break;
748 }
749 return jjStartNfa_0(5, active0, active1, active2);
750 }
751 private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1, long old2, long active2)
752 {
753 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
754 return jjStartNfa_0(5, old0, old1, old2);
755 try { curChar = input_stream.readChar(); }
756 catch(java.io.IOException e) {
757 jjStopStringLiteralDfa_0(6, active0, active1, active2);
758 return 7;
759 }
760 switch(curChar)
761 {
762 case 99:
763 return jjMoveStringLiteralDfa8_0(active0, 0x2000000000L, active1, 0L, active2, 0L);
764 case 101:
765 if ((active0 & 0x80000L) != 0L)
766 return jjStartNfaWithStates_0(7, 19, 35);
767 else if ((active0 & 0x400000000000000L) != 0L)
768 return jjStartNfaWithStates_0(7, 58, 35);
769 return jjMoveStringLiteralDfa8_0(active0, 0x100800000000L, active1, 0x280000000000L, active2, 0L);
770 case 104:
771 return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x2000000000000L, active2, 0x2L);
772 case 105:
773 return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x2000000000000000L, active2, 0L);
774 case 110:
775 return jjMoveStringLiteralDfa8_0(active0, 0x18000200000000L, active1, 0L, active2, 0L);
776 case 112:
777 if ((active0 & 0x2000000000000L) != 0L)
778 return jjStartNfaWithStates_0(7, 49, 35);
779 break;
780 case 115:
781 return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x808000000000000L, active2, 0x8L);
782 case 116:
783 if ((active0 & 0x400L) != 0L)
784 return jjStartNfaWithStates_0(7, 10, 35);
785 break;
786 case 117:
787 return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x20000000000000L, active2, 0x20L);
788 default :
789 break;
790 }
791 return jjStartNfa_0(6, active0, active1, active2);
792 }
793 private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1, long old2, long active2)
794 {
795 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
796 return jjStartNfa_0(6, old0, old1, old2);
797 try { curChar = input_stream.readChar(); }
798 catch(java.io.IOException e) {
799 jjStopStringLiteralDfa_0(7, active0, active1, active2);
800 return 8;
801 }
802 switch(curChar)
803 {
804 case 95:
805 return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x280000000000L, active2, 0L);
806 case 100:
807 if ((active0 & 0x100000000000L) != 0L)
808 return jjStartNfaWithStates_0(8, 44, 35);
809 break;
810 case 101:
811 if ((active0 & 0x2000000000L) != 0L)
812 return jjStartNfaWithStates_0(8, 37, 35);
813 break;
814 case 103:
815 return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x2000000000000000L, active2, 0L);
816 case 104:
817 return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x8000000000000L, active2, 0x8L);
818 case 105:
819 return jjMoveStringLiteralDfa9_0(active0, 0x8000000000000L, active1, 0x802000000000000L, active2, 0x2L);
820 case 110:
821 return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x20000000000000L, active2, 0x20L);
822 case 111:
823 return jjMoveStringLiteralDfa9_0(active0, 0x800000000L, active1, 0L, active2, 0L);
824 case 116:
825 if ((active0 & 0x10000000000000L) != 0L)
826 return jjStartNfaWithStates_0(8, 52, 35);
827 return jjMoveStringLiteralDfa9_0(active0, 0x200000000L, active1, 0L, active2, 0L);
828 default :
829 break;
830 }
831 return jjStartNfa_0(7, active0, active1, active2);
832 }
833 private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1, long old2, long active2)
834 {
835 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
836 return jjStartNfa_0(7, old0, old1, old2);
837 try { curChar = input_stream.readChar(); }
838 catch(java.io.IOException e) {
839 jjStopStringLiteralDfa_0(8, active0, active1, active2);
840 return 9;
841 }
842 switch(curChar)
843 {
844 case 97:
845 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x80000000000L, active2, 0L);
846 case 102:
847 if ((active0 & 0x800000000L) != 0L)
848 return jjStartNfaWithStates_0(9, 35, 35);
849 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x2000000000000L, active2, 0x2L);
850 case 103:
851 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x800000000000000L, active2, 0L);
852 case 105:
853 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x8000000000000L, active2, 0x8L);
854 case 110:
855 if ((active1 & 0x2000000000000000L) != 0L)
856 return jjStopAtPos(9, 125);
857 break;
858 case 111:
859 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x200000000000L, active2, 0L);
860 case 115:
861 if ((active0 & 0x200000000L) != 0L)
862 return jjStartNfaWithStates_0(9, 33, 35);
863 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x20000000000000L, active2, 0x20L);
864 case 122:
865 return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000L, active1, 0L, active2, 0L);
866 default :
867 break;
868 }
869 return jjStartNfa_0(8, active0, active1, active2);
870 }
871 private final int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1, long old2, long active2)
872 {
873 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
874 return jjStartNfa_0(8, old0, old1, old2);
875 try { curChar = input_stream.readChar(); }
876 catch(java.io.IOException e) {
877 jjStopStringLiteralDfa_0(9, active0, active1, active2);
878 return 10;
879 }
880 switch(curChar)
881 {
882 case 101:
883 return jjMoveStringLiteralDfa11_0(active0, 0x8000000000000L, active1, 0L, active2, 0L);
884 case 102:
885 return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x8000000000000L, active2, 0x8L);
886 case 105:
887 return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x20000000000000L, active2, 0x20L);
888 case 110:
889 if ((active1 & 0x800000000000000L) != 0L)
890 return jjStopAtPos(10, 123);
891 return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x80000000000L, active2, 0L);
892 case 114:
893 if ((active1 & 0x200000000000L) != 0L)
894 return jjStopAtPos(10, 109);
895 break;
896 case 116:
897 if ((active1 & 0x2000000000000L) != 0L)
898 {
899 jjmatchedKind = 113;
900 jjmatchedPos = 10;
901 }
902 return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0x2L);
903 default :
904 break;
905 }
906 return jjStartNfa_0(9, active0, active1, active2);
907 }
908 private final int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long active1, long old2, long active2)
909 {
910 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
911 return jjStartNfa_0(9, old0, old1, old2);
912 try { curChar = input_stream.readChar(); }
913 catch(java.io.IOException e) {
914 jjStopStringLiteralDfa_0(10, active0, active1, active2);
915 return 11;
916 }
917 switch(curChar)
918 {
919 case 95:
920 return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0x2L);
921 case 100:
922 if ((active0 & 0x8000000000000L) != 0L)
923 return jjStartNfaWithStates_0(11, 51, 35);
924 else if ((active1 & 0x80000000000L) != 0L)
925 return jjStopAtPos(11, 107);
926 break;
927 case 103:
928 return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x20000000000000L, active2, 0x20L);
929 case 116:
930 if ((active1 & 0x8000000000000L) != 0L)
931 {
932 jjmatchedKind = 115;
933 jjmatchedPos = 11;
934 }
935 return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0x8L);
936 default :
937 break;
938 }
939 return jjStartNfa_0(10, active0, active1, active2);
940 }
941 private final int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long active1, long old2, long active2)
942 {
943 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
944 return jjStartNfa_0(10, old0, old1, old2);
945 try { curChar = input_stream.readChar(); }
946 catch(java.io.IOException e) {
947 jjStopStringLiteralDfa_0(11, 0L, active1, active2);
948 return 12;
949 }
950 switch(curChar)
951 {
952 case 95:
953 return jjMoveStringLiteralDfa13_0(active1, 0L, active2, 0x8L);
954 case 97:
955 return jjMoveStringLiteralDfa13_0(active1, 0L, active2, 0x2L);
956 case 110:
957 return jjMoveStringLiteralDfa13_0(active1, 0x20000000000000L, active2, 0x20L);
958 default :
959 break;
960 }
961 return jjStartNfa_0(11, 0L, active1, active2);
962 }
963 private final int jjMoveStringLiteralDfa13_0(long old1, long active1, long old2, long active2)
964 {
965 if (((active1 &= old1) | (active2 &= old2)) == 0L)
966 return jjStartNfa_0(11, 0L, old1, old2);
967 try { curChar = input_stream.readChar(); }
968 catch(java.io.IOException e) {
969 jjStopStringLiteralDfa_0(12, 0L, active1, active2);
970 return 13;
971 }
972 switch(curChar)
973 {
974 case 97:
975 return jjMoveStringLiteralDfa14_0(active1, 0L, active2, 0x8L);
976 case 101:
977 return jjMoveStringLiteralDfa14_0(active1, 0x20000000000000L, active2, 0x20L);
978 case 115:
979 return jjMoveStringLiteralDfa14_0(active1, 0L, active2, 0x2L);
980 default :
981 break;
982 }
983 return jjStartNfa_0(12, 0L, active1, active2);
984 }
985 private final int jjMoveStringLiteralDfa14_0(long old1, long active1, long old2, long active2)
986 {
987 if (((active1 &= old1) | (active2 &= old2)) == 0L)
988 return jjStartNfa_0(12, 0L, old1, old2);
989 try { curChar = input_stream.readChar(); }
990 catch(java.io.IOException e) {
991 jjStopStringLiteralDfa_0(13, 0L, active1, active2);
992 return 14;
993 }
994 switch(curChar)
995 {
996 case 100:
997 return jjMoveStringLiteralDfa15_0(active1, 0x20000000000000L, active2, 0x20L);
998 case 115:
999 return jjMoveStringLiteralDfa15_0(active1, 0L, active2, 0xaL);
1000 default :
1001 break;
1002 }
1003 return jjStartNfa_0(13, 0L, active1, active2);
1004}
1005private final int jjMoveStringLiteralDfa15_0(long old1, long active1, long old2, long active2)
1006{
1007 if (((active1 &= old1) | (active2 &= old2)) == 0L)
1008 return jjStartNfa_0(13, 0L, old1, old2);
1009 try { curChar = input_stream.readChar(); }
1010 catch(java.io.IOException e) {
1011 jjStopStringLiteralDfa_0(14, 0L, active1, active2);
1012 return 15;
1013 }
1014 switch(curChar)
1015 {
1016 case 95:
1017 return jjMoveStringLiteralDfa16_0(active1, 0x20000000000000L, active2, 0x20L);
1018 case 105:
1019 return jjMoveStringLiteralDfa16_0(active1, 0L, active2, 0x2L);
1020 case 115:
1021 return jjMoveStringLiteralDfa16_0(active1, 0L, active2, 0x8L);
1022 default :
1023 break;
1024 }
1025 return jjStartNfa_0(14, 0L, active1, active2);
1026}
1027private final int jjMoveStringLiteralDfa16_0(long old1, long active1, long old2, long active2)
1028{
1029 if (((active1 &= old1) | (active2 &= old2)) == 0L)
1030 return jjStartNfa_0(14, 0L, old1, old2);
1031 try { curChar = input_stream.readChar(); }
1032 catch(java.io.IOException e) {
1033 jjStopStringLiteralDfa_0(15, 0L, active1, active2);
1034 return 16;
1035 }
1036 switch(curChar)
1037 {
1038 case 103:
1039 return jjMoveStringLiteralDfa17_0(active1, 0L, active2, 0x2L);
1040 case 105:
1041 return jjMoveStringLiteralDfa17_0(active1, 0L, active2, 0x8L);
1042 case 115:
1043 return jjMoveStringLiteralDfa17_0(active1, 0x20000000000000L, active2, 0x20L);
1044 default :
1045 break;
1046 }
1047 return jjStartNfa_0(15, 0L, active1, active2);
1048}
1049private final int jjMoveStringLiteralDfa17_0(long old1, long active1, long old2, long active2)
1050{
1051 if (((active1 &= old1) | (active2 &= old2)) == 0L)
1052 return jjStartNfa_0(15, 0L, old1, old2);
1053 try { curChar = input_stream.readChar(); }
1054 catch(java.io.IOException e) {
1055 jjStopStringLiteralDfa_0(16, 0L, active1, active2);
1056 return 17;
1057 }
1058 switch(curChar)
1059 {
1060 case 103:
1061 return jjMoveStringLiteralDfa18_0(active1, 0L, active2, 0x8L);
1062 case 104:
1063 return jjMoveStringLiteralDfa18_0(active1, 0x20000000000000L, active2, 0x20L);
1064 case 110:
1065 if ((active2 & 0x2L) != 0L)
1066 return jjStopAtPos(17, 129);
1067 break;
1068 default :
1069 break;
1070 }
1071 return jjStartNfa_0(16, 0L, active1, active2);
1072}
1073private final int jjMoveStringLiteralDfa18_0(long old1, long active1, long old2, long active2)
1074{
1075 if (((active1 &= old1) | (active2 &= old2)) == 0L)
1076 return jjStartNfa_0(16, 0L, old1, old2);
1077 try { curChar = input_stream.readChar(); }
1078 catch(java.io.IOException e) {
1079 jjStopStringLiteralDfa_0(17, 0L, active1, active2);
1080 return 18;
1081 }
1082 switch(curChar)
1083 {
1084 case 105:
1085 return jjMoveStringLiteralDfa19_0(active1, 0x20000000000000L, active2, 0x20L);
1086 case 110:
1087 if ((active2 & 0x8L) != 0L)
1088 return jjStopAtPos(18, 131);
1089 break;
1090 default :
1091 break;
1092 }
1093 return jjStartNfa_0(17, 0L, active1, active2);
1094}
1095private final int jjMoveStringLiteralDfa19_0(long old1, long active1, long old2, long active2)
1096{
1097 if (((active1 &= old1) | (active2 &= old2)) == 0L)
1098 return jjStartNfa_0(17, 0L, old1, old2);
1099 try { curChar = input_stream.readChar(); }
1100 catch(java.io.IOException e) {
1101 jjStopStringLiteralDfa_0(18, 0L, active1, active2);
1102 return 19;
1103 }
1104 switch(curChar)
1105 {
1106 case 102:
1107 return jjMoveStringLiteralDfa20_0(active1, 0x20000000000000L, active2, 0x20L);
1108 default :
1109 break;
1110 }
1111 return jjStartNfa_0(18, 0L, active1, active2);
1112}
1113private final int jjMoveStringLiteralDfa20_0(long old1, long active1, long old2, long active2)
1114{
1115 if (((active1 &= old1) | (active2 &= old2)) == 0L)
1116 return jjStartNfa_0(18, 0L, old1, old2);
1117 try { curChar = input_stream.readChar(); }
1118 catch(java.io.IOException e) {
1119 jjStopStringLiteralDfa_0(19, 0L, active1, active2);
1120 return 20;
1121 }
1122 switch(curChar)
1123 {
1124 case 116:
1125 if ((active1 & 0x20000000000000L) != 0L)
1126 {
1127 jjmatchedKind = 117;
1128 jjmatchedPos = 20;
1129 }
1130 return jjMoveStringLiteralDfa21_0(active1, 0L, active2, 0x20L);
1131 default :
1132 break;
1133 }
1134 return jjStartNfa_0(19, 0L, active1, active2);
1135}
1136private final int jjMoveStringLiteralDfa21_0(long old1, long active1, long old2, long active2)
1137{
1138 if (((active1 &= old1) | (active2 &= old2)) == 0L)
1139 return jjStartNfa_0(19, 0L, old1, old2);
1140 try { curChar = input_stream.readChar(); }
1141 catch(java.io.IOException e) {
1142 jjStopStringLiteralDfa_0(20, 0L, 0L, active2);
1143 return 21;
1144 }
1145 switch(curChar)
1146 {
1147 case 95:
1148 return jjMoveStringLiteralDfa22_0(active2, 0x20L);
1149 default :
1150 break;
1151 }
1152 return jjStartNfa_0(20, 0L, 0L, active2);
1153}
1154private final int jjMoveStringLiteralDfa22_0(long old2, long active2)
1155{
1156 if (((active2 &= old2)) == 0L)
1157 return jjStartNfa_0(20, 0L, 0L, old2);
1158 try { curChar = input_stream.readChar(); }
1159 catch(java.io.IOException e) {
1160 jjStopStringLiteralDfa_0(21, 0L, 0L, active2);
1161 return 22;
1162 }
1163 switch(curChar)
1164 {
1165 case 97:
1166 return jjMoveStringLiteralDfa23_0(active2, 0x20L);
1167 default :
1168 break;
1169 }
1170 return jjStartNfa_0(21, 0L, 0L, active2);
1171}
1172private final int jjMoveStringLiteralDfa23_0(long old2, long active2)
1173{
1174 if (((active2 &= old2)) == 0L)
1175 return jjStartNfa_0(21, 0L, 0L, old2);
1176 try { curChar = input_stream.readChar(); }
1177 catch(java.io.IOException e) {
1178 jjStopStringLiteralDfa_0(22, 0L, 0L, active2);
1179 return 23;
1180 }
1181 switch(curChar)
1182 {
1183 case 115:
1184 return jjMoveStringLiteralDfa24_0(active2, 0x20L);
1185 default :
1186 break;
1187 }
1188 return jjStartNfa_0(22, 0L, 0L, active2);
1189}
1190private final int jjMoveStringLiteralDfa24_0(long old2, long active2)
1191{
1192 if (((active2 &= old2)) == 0L)
1193 return jjStartNfa_0(22, 0L, 0L, old2);
1194 try { curChar = input_stream.readChar(); }
1195 catch(java.io.IOException e) {
1196 jjStopStringLiteralDfa_0(23, 0L, 0L, active2);
1197 return 24;
1198 }
1199 switch(curChar)
1200 {
1201 case 115:
1202 return jjMoveStringLiteralDfa25_0(active2, 0x20L);
1203 default :
1204 break;
1205 }
1206 return jjStartNfa_0(23, 0L, 0L, active2);
1207}
1208private final int jjMoveStringLiteralDfa25_0(long old2, long active2)
1209{
1210 if (((active2 &= old2)) == 0L)
1211 return jjStartNfa_0(23, 0L, 0L, old2);
1212 try { curChar = input_stream.readChar(); }
1213 catch(java.io.IOException e) {
1214 jjStopStringLiteralDfa_0(24, 0L, 0L, active2);
1215 return 25;
1216 }
1217 switch(curChar)
1218 {
1219 case 105:
1220 return jjMoveStringLiteralDfa26_0(active2, 0x20L);
1221 default :
1222 break;
1223 }
1224 return jjStartNfa_0(24, 0L, 0L, active2);
1225}
1226private final int jjMoveStringLiteralDfa26_0(long old2, long active2)
1227{
1228 if (((active2 &= old2)) == 0L)
1229 return jjStartNfa_0(24, 0L, 0L, old2);
1230 try { curChar = input_stream.readChar(); }
1231 catch(java.io.IOException e) {
1232 jjStopStringLiteralDfa_0(25, 0L, 0L, active2);
1233 return 26;
1234 }
1235 switch(curChar)
1236 {
1237 case 103:
1238 return jjMoveStringLiteralDfa27_0(active2, 0x20L);
1239 default :
1240 break;
1241 }
1242 return jjStartNfa_0(25, 0L, 0L, active2);
1243}
1244private final int jjMoveStringLiteralDfa27_0(long old2, long active2)
1245{
1246 if (((active2 &= old2)) == 0L)
1247 return jjStartNfa_0(25, 0L, 0L, old2);
1248 try { curChar = input_stream.readChar(); }
1249 catch(java.io.IOException e) {
1250 jjStopStringLiteralDfa_0(26, 0L, 0L, active2);
1251 return 27;
1252 }
1253 switch(curChar)
1254 {
1255 case 110:
1256 if ((active2 & 0x20L) != 0L)
1257 return jjStopAtPos(27, 133);
1258 break;
1259 default :
1260 break;
1261 }
1262 return jjStartNfa_0(26, 0L, 0L, active2);
1263}
1264private final void jjCheckNAdd(int state)
1265{
1266 if (jjrounds[state] != jjround)
1267 {
1268 jjstateSet[jjnewStateCnt++] = state;
1269 jjrounds[state] = jjround;
1270 }
1271}
1272private final void jjAddStates(int start, int end)
1273{
1274 do {
1275 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1276 } while (start++ != end);
1277}
1278private final void jjCheckNAddTwoStates(int state1, int state2)
1279{
1280 jjCheckNAdd(state1);
1281 jjCheckNAdd(state2);
1282}
1283private final void jjCheckNAddStates(int start, int end)
1284{
1285 do {
1286 jjCheckNAdd(jjnextStates[start]);
1287 } while (start++ != end);
1288}
1289private final void jjCheckNAddStates(int start)
1290{
1291 jjCheckNAdd(jjnextStates[start]);
1292 jjCheckNAdd(jjnextStates[start + 1]);
1293}
1294static final long[] jjbitVec0 = {
1295 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
1296};
1297static final long[] jjbitVec1 = {
1298 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
1299};
1300static final long[] jjbitVec3 = {
1301 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
1302};
1303static final long[] jjbitVec4 = {
1304 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
1305};
1306static final long[] jjbitVec5 = {
1307 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
1308};
1309static final long[] jjbitVec6 = {
1310 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
1311};
1312static final long[] jjbitVec7 = {
1313 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
1314};
1315static final long[] jjbitVec8 = {
1316 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
1317};
1318private final int jjMoveNfa_0(int startState, int curPos)
1319{
1320 int[] nextStates;
1321 int startsAt = 0;
1322 jjnewStateCnt = 74;
1323 int i = 1;
1324 jjstateSet[0] = startState;
1325 int j, kind = 0x7fffffff;
1326 for (;;)
1327 {
1328 if (++jjround == 0x7fffffff)
1329 ReInitRounds();
1330 if (curChar < 64)
1331 {
1332 long l = 1L << curChar;
1333 MatchLoop: do
1334 {
1335 switch(jjstateSet[--i])
1336 {
1337 case 6:
1338 if ((0x1ffffffffL & l) != 0L)
1339 {
1340 if (kind > 6)
1341 kind = 6;
1342 jjCheckNAdd(0);
1343 }
1344 else if ((0x3ff000000000000L & l) != 0L)
1345 jjCheckNAddStates(0, 6);
1346 else if (curChar == 47)
1347 jjAddStates(7, 9);
1348 else if (curChar == 36)
1349 {
1350 if (kind > 69)
1351 kind = 69;
1352 jjCheckNAdd(35);
1353 }
1354 else if (curChar == 34)
1355 jjCheckNAddStates(10, 12);
1356 else if (curChar == 39)
1357 jjAddStates(13, 14);
1358 else if (curChar == 46)
1359 jjCheckNAdd(11);
1360 else if (curChar == 35)
1361 jjstateSet[jjnewStateCnt++] = 1;
1362 if ((0x3fe000000000000L & l) != 0L)
1363 {
1364 if (kind > 60)
1365 kind = 60;
1366 jjCheckNAddTwoStates(8, 9);
1367 }
1368 else if (curChar == 48)
1369 {
1370 if (kind > 60)
1371 kind = 60;
1372 jjCheckNAddStates(15, 17);
1373 }
1374 break;
1375 case 56:
1376 if (curChar == 42)
1377 jjstateSet[jjnewStateCnt++] = 67;
1378 else if (curChar == 47)
1379 {
1380 if (kind > 7)
1381 kind = 7;
1382 jjCheckNAddStates(18, 20);
1383 }
1384 if (curChar == 42)
1385 jjCheckNAdd(62);
1386 break;
1387 case 0:
1388 if ((0x1ffffffffL & l) == 0L)
1389 break;
1390 if (kind > 6)
1391 kind = 6;
1392 jjCheckNAdd(0);
1393 break;
1394 case 1:
1395 if (curChar == 33)
1396 jjCheckNAddStates(21, 23);
1397 break;
1398 case 2:
1399 if ((0xffffffffffffdbffL & l) != 0L)
1400 jjCheckNAddStates(21, 23);
1401 break;
1402 case 3:
1403 if ((0x2400L & l) != 0L && kind > 8)
1404 kind = 8;
1405 break;
1406 case 4:
1407 if (curChar == 10 && kind > 8)
1408 kind = 8;
1409 break;
1410 case 5:
1411 if (curChar == 13)
1412 jjstateSet[jjnewStateCnt++] = 4;
1413 break;
1414 case 7:
1415 if ((0x3fe000000000000L & l) == 0L)
1416 break;
1417 if (kind > 60)
1418 kind = 60;
1419 jjCheckNAddTwoStates(8, 9);
1420 break;
1421 case 8:
1422 if ((0x3ff000000000000L & l) == 0L)
1423 break;
1424 if (kind > 60)
1425 kind = 60;
1426 jjCheckNAddTwoStates(8, 9);
1427 break;
1428 case 10:
1429 if (curChar == 46)
1430 jjCheckNAdd(11);
1431 break;
1432 case 11:
1433 if ((0x3ff000000000000L & l) == 0L)
1434 break;
1435 if (kind > 64)
1436 kind = 64;
1437 jjCheckNAddStates(24, 26);
1438 break;
1439 case 13:
1440 if ((0x280000000000L & l) != 0L)
1441 jjCheckNAdd(14);
1442 break;
1443 case 14:
1444 if ((0x3ff000000000000L & l) == 0L)
1445 break;
1446 if (kind > 64)
1447 kind = 64;
1448 jjCheckNAddTwoStates(14, 15);
1449 break;
1450 case 16:
1451 if (curChar == 39)
1452 jjAddStates(13, 14);
1453 break;
1454 case 17:
1455 if ((0xffffff7fffffdbffL & l) != 0L)
1456 jjCheckNAdd(18);
1457 break;
1458 case 18:
1459 if (curChar == 39 && kind > 66)
1460 kind = 66;
1461 break;
1462 case 20:
1463 if ((0x8400000000L & l) != 0L)
1464 jjCheckNAdd(18);
1465 break;
1466 case 21:
1467 if ((0xff000000000000L & l) != 0L)
1468 jjCheckNAddTwoStates(22, 18);
1469 break;
1470 case 22:
1471 if ((0xff000000000000L & l) != 0L)
1472 jjCheckNAdd(18);
1473 break;
1474 case 23:
1475 if ((0xf000000000000L & l) != 0L)
1476 jjstateSet[jjnewStateCnt++] = 24;
1477 break;
1478 case 24:
1479 if ((0xff000000000000L & l) != 0L)
1480 jjCheckNAdd(22);
1481 break;
1482 case 25:
1483 if (curChar == 34)
1484 jjCheckNAddStates(10, 12);
1485 break;
1486 case 26:
1487 if ((0xfffffffbffffdbffL & l) != 0L)
1488 jjCheckNAddStates(10, 12);
1489 break;
1490 case 28:
1491 if ((0x8400000000L & l) != 0L)
1492 jjCheckNAddStates(10, 12);
1493 break;
1494 case 29:
1495 if (curChar == 34 && kind > 67)
1496 kind = 67;
1497 break;
1498 case 30:
1499 if ((0xff000000000000L & l) != 0L)
1500 jjCheckNAddStates(27, 30);
1501 break;
1502 case 31:
1503 if ((0xff000000000000L & l) != 0L)
1504 jjCheckNAddStates(10, 12);
1505 break;
1506 case 32:
1507 if ((0xf000000000000L & l) != 0L)
1508 jjstateSet[jjnewStateCnt++] = 33;
1509 break;
1510 case 33:
1511 if ((0xff000000000000L & l) != 0L)
1512 jjCheckNAdd(31);
1513 break;
1514 case 34:
1515 if (curChar != 36)
1516 break;
1517 if (kind > 69)
1518 kind = 69;
1519 jjCheckNAdd(35);
1520 break;
1521 case 35:
1522 if ((0x3ff001000000000L & l) == 0L)
1523 break;
1524 if (kind > 69)
1525 kind = 69;
1526 jjCheckNAdd(35);
1527 break;
1528 case 36:
1529 if ((0x3ff000000000000L & l) != 0L)
1530 jjCheckNAddStates(0, 6);
1531 break;
1532 case 37:
1533 if ((0x3ff000000000000L & l) != 0L)
1534 jjCheckNAddTwoStates(37, 38);
1535 break;
1536 case 38:
1537 if (curChar != 46)
1538 break;
1539 if (kind > 64)
1540 kind = 64;
1541 jjCheckNAddStates(31, 33);
1542 break;
1543 case 39:
1544 if ((0x3ff000000000000L & l) == 0L)
1545 break;
1546 if (kind > 64)
1547 kind = 64;
1548 jjCheckNAddStates(31, 33);
1549 break;
1550 case 41:
1551 if ((0x280000000000L & l) != 0L)
1552 jjCheckNAdd(42);
1553 break;
1554 case 42:
1555 if ((0x3ff000000000000L & l) == 0L)
1556 break;
1557 if (kind > 64)
1558 kind = 64;
1559 jjCheckNAddTwoStates(42, 15);
1560 break;
1561 case 43:
1562 if ((0x3ff000000000000L & l) != 0L)
1563 jjCheckNAddTwoStates(43, 44);
1564 break;
1565 case 45:
1566 if ((0x280000000000L & l) != 0L)
1567 jjCheckNAdd(46);
1568 break;
1569 case 46:
1570 if ((0x3ff000000000000L & l) == 0L)
1571 break;
1572 if (kind > 64)
1573 kind = 64;
1574 jjCheckNAddTwoStates(46, 15);
1575 break;
1576 case 47:
1577 if ((0x3ff000000000000L & l) != 0L)
1578 jjCheckNAddStates(34, 36);
1579 break;
1580 case 49:
1581 if ((0x280000000000L & l) != 0L)
1582 jjCheckNAdd(50);
1583 break;
1584 case 50:
1585 if ((0x3ff000000000000L & l) != 0L)
1586 jjCheckNAddTwoStates(50, 15);
1587 break;
1588 case 51:
1589 if (curChar != 48)
1590 break;
1591 if (kind > 60)
1592 kind = 60;
1593 jjCheckNAddStates(15, 17);
1594 break;
1595 case 53:
1596 if ((0x3ff000000000000L & l) == 0L)
1597 break;
1598 if (kind > 60)
1599 kind = 60;
1600 jjCheckNAddTwoStates(53, 9);
1601 break;
1602 case 54:
1603 if ((0xff000000000000L & l) == 0L)
1604 break;
1605 if (kind > 60)
1606 kind = 60;
1607 jjCheckNAddTwoStates(54, 9);
1608 break;
1609 case 55:
1610 if (curChar == 47)
1611 jjAddStates(7, 9);
1612 break;
1613 case 57:
1614 if ((0xffffffffffffdbffL & l) == 0L)
1615 break;
1616 if (kind > 7)
1617 kind = 7;
1618 jjCheckNAddStates(18, 20);
1619 break;
1620 case 58:
1621 if ((0x2400L & l) != 0L && kind > 7)
1622 kind = 7;
1623 break;
1624 case 59:
1625 if (curChar == 10 && kind > 7)
1626 kind = 7;
1627 break;
1628 case 60:
1629 if (curChar == 13)
1630 jjstateSet[jjnewStateCnt++] = 59;
1631 break;
1632 case 61:
1633 if (curChar == 42)
1634 jjCheckNAdd(62);
1635 break;
1636 case 62:
1637 if ((0xfffffbffffffffffL & l) != 0L)
1638 jjCheckNAddTwoStates(62, 63);
1639 break;
1640 case 63:
1641 if (curChar == 42)
1642 jjCheckNAddStates(37, 39);
1643 break;
1644 case 64:
1645 if ((0xffff7bffffffffffL & l) != 0L)
1646 jjCheckNAddTwoStates(65, 63);
1647 break;
1648 case 65:
1649 if ((0xfffffbffffffffffL & l) != 0L)
1650 jjCheckNAddTwoStates(65, 63);
1651 break;
1652 case 66:
1653 if (curChar == 47 && kind > 9)
1654 kind = 9;
1655 break;
1656 case 67:
1657 if (curChar == 42)
1658 jjCheckNAddTwoStates(68, 69);
1659 break;
1660 case 68:
1661 if ((0xfffffbffffffffffL & l) != 0L)
1662 jjCheckNAddTwoStates(68, 69);
1663 break;
1664 case 69:
1665 if (curChar == 42)
1666 jjCheckNAddStates(40, 42);
1667 break;
1668 case 70:
1669 if ((0xffff7bffffffffffL & l) != 0L)
1670 jjCheckNAddTwoStates(71, 69);
1671 break;
1672 case 71:
1673 if ((0xfffffbffffffffffL & l) != 0L)
1674 jjCheckNAddTwoStates(71, 69);
1675 break;
1676 case 72:
1677 if (curChar == 47 && kind > 68)
1678 kind = 68;
1679 break;
1680 case 73:
1681 if (curChar == 42)
1682 jjstateSet[jjnewStateCnt++] = 67;
1683 break;
1684 default : break;
1685 }
1686 } while(i != startsAt);
1687 }
1688 else if (curChar < 128)
1689 {
1690 long l = 1L << (curChar & 077);
1691 MatchLoop: do
1692 {
1693 switch(jjstateSet[--i])
1694 {
1695 case 6:
1696 case 35:
1697 if ((0x7fffffe87fffffeL & l) == 0L)
1698 break;
1699 if (kind > 69)
1700 kind = 69;
1701 jjCheckNAdd(35);
1702 break;
1703 case 2:
1704 jjAddStates(21, 23);
1705 break;
1706 case 9:
1707 if ((0x100000001000L & l) != 0L && kind > 60)
1708 kind = 60;
1709 break;
1710 case 12:
1711 if ((0x2000000020L & l) != 0L)
1712 jjAddStates(43, 44);
1713 break;
1714 case 15:
1715 if ((0x5000000050L & l) != 0L && kind > 64)
1716 kind = 64;
1717 break;
1718 case 17:
1719 if ((0xffffffffefffffffL & l) != 0L)
1720 jjCheckNAdd(18);
1721 break;
1722 case 19:
1723 if (curChar == 92)
1724 jjAddStates(45, 47);
1725 break;
1726 case 20:
1727 if ((0x14404410000000L & l) != 0L)
1728 jjCheckNAdd(18);
1729 break;
1730 case 26:
1731 if ((0xffffffffefffffffL & l) != 0L)
1732 jjCheckNAddStates(10, 12);
1733 break;
1734 case 27:
1735 if (curChar == 92)
1736 jjAddStates(48, 50);
1737 break;
1738 case 28:
1739 if ((0x14404410000000L & l) != 0L)
1740 jjCheckNAddStates(10, 12);
1741 break;
1742 case 40:
1743 if ((0x2000000020L & l) != 0L)
1744 jjAddStates(51, 52);
1745 break;
1746 case 44:
1747 if ((0x2000000020L & l) != 0L)
1748 jjAddStates(53, 54);
1749 break;
1750 case 48:
1751 if ((0x2000000020L & l) != 0L)
1752 jjAddStates(55, 56);
1753 break;
1754 case 52:
1755 if ((0x100000001000000L & l) != 0L)
1756 jjCheckNAdd(53);
1757 break;
1758 case 53:
1759 if ((0x7e0000007eL & l) == 0L)
1760 break;
1761 if (kind > 60)
1762 kind = 60;
1763 jjCheckNAddTwoStates(53, 9);
1764 break;
1765 case 57:
1766 if (kind > 7)
1767 kind = 7;
1768 jjAddStates(18, 20);
1769 break;
1770 case 62:
1771 jjCheckNAddTwoStates(62, 63);
1772 break;
1773 case 64:
1774 case 65:
1775 jjCheckNAddTwoStates(65, 63);
1776 break;
1777 case 68:
1778 jjCheckNAddTwoStates(68, 69);
1779 break;
1780 case 70:
1781 case 71:
1782 jjCheckNAddTwoStates(71, 69);
1783 break;
1784 default : break;
1785 }
1786 } while(i != startsAt);
1787 }
1788 else
1789 {
1790 int hiByte = (int)(curChar >> 8);
1791 int i1 = hiByte >> 6;
1792 long l1 = 1L << (hiByte & 077);
1793 int i2 = (curChar & 0xff) >> 6;
1794 long l2 = 1L << (curChar & 077);
1795 MatchLoop: do
1796 {
1797 switch(jjstateSet[--i])
1798 {
1799 case 6:
1800 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1801 {
1802 if (kind > 6)
1803 kind = 6;
1804 jjCheckNAdd(0);
1805 }
1806 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1807 {
1808 if (kind > 69)
1809 kind = 69;
1810 jjCheckNAdd(35);
1811 }
1812 break;
1813 case 0:
1814 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1815 break;
1816 if (kind > 6)
1817 kind = 6;
1818 jjCheckNAdd(0);
1819 break;
1820 case 2:
1821 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1822 jjAddStates(21, 23);
1823 break;
1824 case 17:
1825 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1826 jjstateSet[jjnewStateCnt++] = 18;
1827 break;
1828 case 26:
1829 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1830 jjAddStates(10, 12);
1831 break;
1832 case 34:
1833 case 35:
1834 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1835 break;
1836 if (kind > 69)
1837 kind = 69;
1838 jjCheckNAdd(35);
1839 break;
1840 case 57:
1841 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1842 break;
1843 if (kind > 7)
1844 kind = 7;
1845 jjAddStates(18, 20);
1846 break;
1847 case 62:
1848 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1849 jjCheckNAddTwoStates(62, 63);
1850 break;
1851 case 64:
1852 case 65:
1853 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1854 jjCheckNAddTwoStates(65, 63);
1855 break;
1856 case 68:
1857 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1858 jjCheckNAddTwoStates(68, 69);
1859 break;
1860 case 70:
1861 case 71:
1862 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1863 jjCheckNAddTwoStates(71, 69);
1864 break;
1865 default : break;
1866 }
1867 } while(i != startsAt);
1868 }
1869 if (kind != 0x7fffffff)
1870 {
1871 jjmatchedKind = kind;
1872 jjmatchedPos = curPos;
1873 kind = 0x7fffffff;
1874 }
1875 ++curPos;
1876 if ((i = jjnewStateCnt) == (startsAt = 74 - (jjnewStateCnt = startsAt)))
1877 return curPos;
1878 try { curChar = input_stream.readChar(); }
1879 catch(java.io.IOException e) { return curPos; }
1880 }
1881}
1882static final int[] jjnextStates = {
1883 37, 38, 43, 44, 47, 48, 15, 56, 61, 73, 26, 27, 29, 17, 19, 52,
1884 54, 9, 57, 58, 60, 2, 3, 5, 11, 12, 15, 26, 27, 31, 29, 39,
1885 40, 15, 47, 48, 15, 63, 64, 66, 69, 70, 72, 13, 14, 20, 21, 23,
1886 28, 30, 32, 41, 42, 45, 46, 49, 50,
1887};
1888private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1889{
1890 switch(hiByte)
1891 {
1892 case 0:
1893 return ((jjbitVec0[i2] & l2) != 0L);
1894 default :
1895 return false;
1896 }
1897}
1898private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1899{
1900 switch(hiByte)
1901 {
1902 case 0:
1903 return ((jjbitVec0[i2] & l2) != 0L);
1904 default :
1905 if ((jjbitVec1[i1] & l1) != 0L)
1906 return true;
1907 return false;
1908 }
1909}
1910private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1911{
1912 switch(hiByte)
1913 {
1914 case 0:
1915 return ((jjbitVec4[i2] & l2) != 0L);
1916 case 48:
1917 return ((jjbitVec5[i2] & l2) != 0L);
1918 case 49:
1919 return ((jjbitVec6[i2] & l2) != 0L);
1920 case 51:
1921 return ((jjbitVec7[i2] & l2) != 0L);
1922 case 61:
1923 return ((jjbitVec8[i2] & l2) != 0L);
1924 default :
1925 if ((jjbitVec3[i1] & l1) != 0L)
1926 return true;
1927 return false;
1928 }
1929}
1930public static final String [] jjstrLiteralImages = {
1931"", null, null, null, null, null, null, null, null, null,
1932"\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153",
1933"\143\154\141\163\163", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150",
1934"\143\150\141\162", "\143\157\156\163\164", "\143\157\156\164\151\156\165\145",
1935"\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
1936"\145\156\165\155", "\145\170\164\145\156\144\163", "\146\141\154\163\145",
1937"\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162",
1938"\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163",
1939"\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1940"\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167",
1941"\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145",
1942"\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156",
1943"\163\150\157\162\164", "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160",
1944"\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144",
1945"\164\162\141\156\163\151\145\156\164", "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\165\145",
1946"\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
1947"\167\150\151\154\145", null, null, null, null, null, null, null, null, null, null, null, null, "\50",
1948"\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76",
1949"\100\147\164", "\74", "\100\154\164", "\41", "\176", "\77", "\72", "\75\75", "\74\75",
1950"\100\154\164\145\161", "\76\75", "\100\147\164\145\161", "\41\75", "\174\174", "\100\157\162",
1951"\46\46", "\100\141\156\144", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46",
1952"\100\142\151\164\167\151\163\145\137\141\156\144", "\174", "\100\142\151\164\167\151\163\145\137\157\162", "\136", "\45",
1953"\74\74", "\100\154\145\146\164\137\163\150\151\146\164", "\76\76",
1954"\100\162\151\147\150\164\137\163\150\151\146\164", "\76\76\76",
1955"\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75",
1956"\100\141\156\144\137\141\163\163\151\147\156", "\174\75", "\100\157\162\137\141\163\163\151\147\156", "\136\75", "\45\75",
1957"\74\74\75", "\100\154\145\146\164\137\163\150\151\146\164\137\141\163\163\151\147\156",
1958"\76\76\75",
1959"\100\162\151\147\150\164\137\163\150\151\146\164\137\141\163\163\151\147\156", "\76\76\76\75",
1960"\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164\137\141\163\163\151\147\156", };
1961public static final String [] lexStateNames = {
1962 "DEFAULT",
1963};
1964static final long[] jjtoToken = {
1965 0x1ffffffffffffc01L, 0xffffffffffffff3dL, 0x3fL,
1966};
1967static final long[] jjtoSkip = {
1968 0x3feL, 0x0L, 0x0L,
1969};
1970static final long[] jjtoSpecial = {
1971 0x380L, 0x0L, 0x0L,
1972};
1973protected JavaCharStream input_stream;
1974private final int[] jjrounds = new int[74];
1975private final int[] jjstateSet = new int[148];
1976protected char curChar;
1977public ParserTokenManager(JavaCharStream stream)
1978{
1979 if (JavaCharStream.staticFlag)
1980 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1981 input_stream = stream;
1982}
1983public ParserTokenManager(JavaCharStream stream, int lexState)
1984{
1985 this(stream);
1986 SwitchTo(lexState);
1987}
1988public void ReInit(JavaCharStream stream)
1989{
1990 jjmatchedPos = jjnewStateCnt = 0;
1991 curLexState = defaultLexState;
1992 input_stream = stream;
1993 ReInitRounds();
1994}
1995private final void ReInitRounds()
1996{
1997 int i;
1998 jjround = 0x80000001;
1999 for (i = 74; i-- > 0;)
2000 jjrounds[i] = 0x80000000;
2001}
2002public void ReInit(JavaCharStream stream, int lexState)
2003{
2004 ReInit(stream);
2005 SwitchTo(lexState);
2006}
2007public void SwitchTo(int lexState)
2008{
2009 if (lexState >= 1 || lexState < 0)
2010 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2011 else
2012 curLexState = lexState;
2013}
2014
2015protected Token jjFillToken()
2016{
2017 Token t = Token.newToken(jjmatchedKind);
2018 t.kind = jjmatchedKind;
2019 String im = jjstrLiteralImages[jjmatchedKind];
2020 t.image = (im == null) ? input_stream.GetImage() : im;
2021 t.beginLine = input_stream.getBeginLine();
2022 t.beginColumn = input_stream.getBeginColumn();
2023 t.endLine = input_stream.getEndLine();
2024 t.endColumn = input_stream.getEndColumn();
2025 return t;
2026}
2027
2028int curLexState = 0;
2029int defaultLexState = 0;
2030int jjnewStateCnt;
2031int jjround;
2032int jjmatchedPos;
2033int jjmatchedKind;
2034
2035public Token getNextToken()
2036{
2037 int kind;
2038 Token specialToken = null;
2039 Token matchedToken;
2040 int curPos = 0;
2041
2042 EOFLoop :
2043 for (;;)
2044 {
2045 try
2046 {
2047 curChar = input_stream.BeginToken();
2048 }
2049 catch(java.io.IOException e)
2050 {
2051 jjmatchedKind = 0;
2052 matchedToken = jjFillToken();
2053 matchedToken.specialToken = specialToken;
2054 return matchedToken;
2055 }
2056
2057 jjmatchedKind = 0x7fffffff;
2058 jjmatchedPos = 0;
2059 curPos = jjMoveStringLiteralDfa0_0();
2060 if (jjmatchedKind != 0x7fffffff)
2061 {
2062 if (jjmatchedPos + 1 < curPos)
2063 input_stream.backup(curPos - jjmatchedPos - 1);
2064 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2065 {
2066 matchedToken = jjFillToken();
2067 matchedToken.specialToken = specialToken;
2068 return matchedToken;
2069 }
2070 else
2071 {
2072 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2073 {
2074 matchedToken = jjFillToken();
2075 if (specialToken == null)
2076 specialToken = matchedToken;
2077 else
2078 {
2079 matchedToken.specialToken = specialToken;
2080 specialToken = (specialToken.next = matchedToken);
2081 }
2082 }
2083 continue EOFLoop;
2084 }
2085 }
2086 int error_line = input_stream.getEndLine();
2087 int error_column = input_stream.getEndColumn();
2088 String error_after = null;
2089 boolean EOFSeen = false;
2090 try { input_stream.readChar(); input_stream.backup(1); }
2091 catch (java.io.IOException e1) {
2092 EOFSeen = true;
2093 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2094 if (curChar == '\n' || curChar == '\r') {
2095 error_line++;
2096 error_column = 0;
2097 }
2098 else
2099 error_column++;
2100 }
2101 if (!EOFSeen) {
2102 input_stream.backup(1);
2103 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2104 }
2105 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2106 }
2107}
2108
2109}
2110 |
Popular Tags |
Java API By Example, From Geeks To Geeks.