1
2
3 package org.apache.commons.jexl3.parser;
4 import java.util.Collections;
5 import java.util.List;
6 import java.util.ArrayList;
7 import java.util.LinkedList;
8 import org.apache.commons.jexl3.JexlInfo;
9 import org.apache.commons.jexl3.JexlFeatures;
10 import org.apache.commons.jexl3.JexlException;
11 import org.apache.commons.jexl3.internal.Scope;
12
13
14 @SuppressWarnings ("unused")
15 public class ParserTokenManager implements ParserConstants {
16 boolean comparatorNames = false;
17 boolean jexl331 = true;
18 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1){
19 switch (pos)
20 {
21 case 0:
22 if ((active0 & 0x600003e00L) != 0x0L || (active1 & 0xfffffe380000L) != 0x0L)
23 {
24 jjmatchedKind = 114;
25 return 74;
26 }
27 if ((active1 & 0x1000000L) != 0x0L)
28 return 54;
29 if ((active0 & 0x5000000L) != 0x0L || (active1 & 0x40000L) != 0x0L)
30 return 12;
31 if ((active1 & 0x20000L) != 0x0L)
32 return 33;
33 if ((active0 & 0x400000000000000L) != 0x0L || (active1 & 0x100L) != 0x0L)
34 return 63;
35 return -1;
36 case 1:
37 if ((active0 & 0x200003e00L) != 0x0L || (active1 & 0xfffff4380000L) != 0x0L)
38 {
39 if (jjmatchedPos != 1)
40 {
41 jjmatchedKind = 114;
42 jjmatchedPos = 1;
43 }
44 return 74;
45 }
46 if ((active0 & 0x400000000L) != 0x0L || (active1 & 0xa000000L) != 0x0L)
47 return 74;
48 return -1;
49 case 2:
50 if ((active0 & 0x200000400L) != 0x0L || (active1 & 0x806420380000L) != 0x0L)
51 return 74;
52 if ((active0 & 0x3a00L) != 0x0L || (active1 & 0x7f9bd4000000L) != 0x0L)
53 {
54 if (jjmatchedPos != 2)
55 {
56 jjmatchedKind = 114;
57 jjmatchedPos = 2;
58 }
59 return 74;
60 }
61 return -1;
62 case 3:
63 if ((active0 & 0x3a00L) != 0x0L || (active1 & 0x6c93d0000000L) != 0x0L)
64 {
65 jjmatchedKind = 114;
66 jjmatchedPos = 3;
67 return 74;
68 }
69 if ((active1 & 0x130804000000L) != 0x0L)
70 return 74;
71 return -1;
72 case 4:
73 if ((active0 & 0x3000L) != 0x0L || (active1 & 0x680380000000L) != 0x0L)
74 {
75 jjmatchedKind = 114;
76 jjmatchedPos = 4;
77 return 74;
78 }
79 if ((active0 & 0xa00L) != 0x0L || (active1 & 0x49050000000L) != 0x0L)
80 return 74;
81 return -1;
82 case 5:
83 if ((active0 & 0x3000L) != 0x0L || (active1 & 0x200180000000L) != 0x0L)
84 {
85 jjmatchedKind = 114;
86 jjmatchedPos = 5;
87 return 74;
88 }
89 if ((active1 & 0x480200000000L) != 0x0L)
90 return 74;
91 return -1;
92 case 6:
93 if ((active0 & 0x2000L) != 0x0L || (active1 & 0x180000000L) != 0x0L)
94 {
95 jjmatchedKind = 114;
96 jjmatchedPos = 6;
97 return 74;
98 }
99 if ((active0 & 0x1000L) != 0x0L || (active1 & 0x200000000000L) != 0x0L)
100 return 74;
101 return -1;
102 case 7:
103 if ((active0 & 0x2000L) != 0x0L)
104 {
105 jjmatchedKind = 114;
106 jjmatchedPos = 7;
107 return 74;
108 }
109 if ((active1 & 0x180000000L) != 0x0L)
110 return 74;
111 return -1;
112 case 8:
113 if ((active0 & 0x2000L) != 0x0L)
114 {
115 jjmatchedKind = 114;
116 jjmatchedPos = 8;
117 return 74;
118 }
119 return -1;
120 case 9:
121 if ((active0 & 0x2000L) != 0x0L)
122 return 74;
123 return -1;
124 default :
125 return -1;
126 }
127 }
128 private final int jjStartNfa_0(int pos, long active0, long active1){
129 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
130 }
131 private int jjStopAtPos(int pos, int kind)
132 {
133 jjmatchedKind = kind;
134 jjmatchedPos = pos;
135 return pos + 1;
136 }
137 private int jjMoveStringLiteralDfa0_0(){
138 switch(curChar)
139 {
140 case '!':
141 jjmatchedKind = 74;
142 return jjMoveStringLiteralDfa1_0(0x1641100000000L, 0x0L);
143 case '#':
144 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000L);
145 case '%':
146 jjmatchedKind = 73;
147 return jjMoveStringLiteralDfa1_0(0x800000000000000L, 0x0L);
148 case '&':
149 jjmatchedKind = 75;
150 return jjMoveStringLiteralDfa1_0(0x1000000040000000L, 0x0L);
151 case '(':
152 return jjStopAtPos(0, 14);
153 case ')':
154 return jjStopAtPos(0, 15);
155 case '*':
156 jjmatchedKind = 71;
157 return jjMoveStringLiteralDfa1_0(0x200000000000000L, 0x0L);
158 case '+':
159 jjmatchedKind = 67;
160 return jjMoveStringLiteralDfa1_0(0x80000000000000L, 0x10L);
161 case ',':
162 return jjStopAtPos(0, 23);
163 case '-':
164 jjmatchedKind = 69;
165 return jjMoveStringLiteralDfa1_0(0x100000000000000L, 0x400040L);
166 case '.':
167 jjmatchedKind = 24;
168 return jjMoveStringLiteralDfa1_0(0x4000000L, 0x40000L);
169 case '/':
170 jjmatchedKind = 72;
171 return jjMoveStringLiteralDfa1_0(0x400000000000000L, 0x0L);
172 case ':':
173 return jjStopAtPos(0, 22);
174 case ';':
175 return jjStopAtPos(0, 21);
176 case '<':
177 jjmatchedKind = 39;
178 return jjMoveStringLiteralDfa1_0(0x8000010000000000L, 0x4000L);
179 case '=':
180 jjmatchedKind = 66;
181 return jjMoveStringLiteralDfa1_0(0x9a0800000000L, 0x800000L);
182 case '>':
183 jjmatchedKind = 37;
184 return jjMoveStringLiteralDfa1_0(0x4000000000L, 0x18003L);
185 case '?':
186 jjmatchedKind = 27;
187 return jjMoveStringLiteralDfa1_0(0x32080000L, 0x0L);
188 case 'N':
189 return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L);
190 case '[':
191 return jjStopAtPos(0, 18);
192 case ']':
193 return jjStopAtPos(0, 20);
194 case '^':
195 jjmatchedKind = 77;
196 return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L);
197 case 'a':
198 return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L);
199 case 'b':
200 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L);
201 case 'c':
202 return jjMoveStringLiteralDfa1_0(0x800L, 0x108080000000L);
203 case 'd':
204 return jjMoveStringLiteralDfa1_0(0x0L, 0x200008100000L);
205 case 'e':
206 return jjMoveStringLiteralDfa1_0(0x0L, 0x1004000000L);
207 case 'f':
208 return jjMoveStringLiteralDfa1_0(0x1000L, 0x40120000000L);
209 case 'i':
210 return jjMoveStringLiteralDfa1_0(0x2000L, 0x400002000000L);
211 case 'l':
212 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000L);
213 case 'm':
214 return jjMoveStringLiteralDfa1_0(0x0L, 0x200000L);
215 case 'n':
216 return jjMoveStringLiteralDfa1_0(0x0L, 0x10400080000L);
217 case 'o':
218 return jjMoveStringLiteralDfa1_0(0x400000000L, 0x0L);
219 case 'r':
220 return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000L);
221 case 's':
222 return jjMoveStringLiteralDfa1_0(0x0L, 0x80800000000L);
223 case 't':
224 return jjMoveStringLiteralDfa1_0(0x600L, 0x20000000000L);
225 case 'v':
226 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000L);
227 case 'w':
228 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
229 case '{':
230 return jjStopAtPos(0, 16);
231 case '|':
232 jjmatchedKind = 76;
233 return jjMoveStringLiteralDfa1_0(0x2000000080000000L, 0x0L);
234 case '}':
235 return jjStopAtPos(0, 17);
236 case '~':
237 return jjStartNfaWithStates_0(0, 81, 33);
238 default :
239 return jjMoveNfa_0(0, 0);
240 }
241 }
242 private int jjMoveStringLiteralDfa1_0(long active0, long active1){
243 try { curChar = input_stream.readChar(); }
244 catch(java.io.IOException e) {
245 jjStopStringLiteralDfa_0(0, active0, active1);
246 return 1;
247 }
248 switch(curChar)
249 {
250 case '$':
251 if ((active0 & 0x100000000000L) != 0x0L)
252 return jjStopAtPos(1, 44);
253 else if ((active0 & 0x400000000000L) != 0x0L)
254 return jjStopAtPos(1, 46);
255 break;
256 case '&':
257 if ((active0 & 0x40000000L) != 0x0L)
258 return jjStopAtPos(1, 30);
259 break;
260 case '+':
261 if ((active1 & 0x10L) != 0x0L)
262 return jjStopAtPos(1, 68);
263 break;
264 case '-':
265 if ((active1 & 0x40L) != 0x0L)
266 return jjStopAtPos(1, 70);
267 break;
268 case '.':
269 if ((active0 & 0x2000000L) != 0x0L)
270 return jjStopAtPos(1, 25);
271 else if ((active1 & 0x40000L) != 0x0L)
272 {
273 jjmatchedKind = 82;
274 jjmatchedPos = 1;
275 }
276 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L);
277 case ':':
278 if ((active0 & 0x10000000L) != 0x0L)
279 return jjStopAtPos(1, 28);
280 break;
281 case '<':
282 if ((active1 & 0x4000L) != 0x0L)
283 {
284 jjmatchedKind = 78;
285 jjmatchedPos = 1;
286 }
287 return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000000L, active1, 0x0L);
288 case '=':
289 if ((active0 & 0x800000000L) != 0x0L)
290 {
291 jjmatchedKind = 35;
292 jjmatchedPos = 1;
293 }
294 else if ((active0 & 0x1000000000L) != 0x0L)
295 {
296 jjmatchedKind = 36;
297 jjmatchedPos = 1;
298 }
299 else if ((active0 & 0x4000000000L) != 0x0L)
300 return jjStopAtPos(1, 38);
301 else if ((active0 & 0x10000000000L) != 0x0L)
302 return jjStopAtPos(1, 40);
303 else if ((active0 & 0x80000000000000L) != 0x0L)
304 return jjStopAtPos(1, 55);
305 else if ((active0 & 0x100000000000000L) != 0x0L)
306 return jjStopAtPos(1, 56);
307 else if ((active0 & 0x200000000000000L) != 0x0L)
308 return jjStopAtPos(1, 57);
309 else if ((active0 & 0x400000000000000L) != 0x0L)
310 return jjStopAtPos(1, 58);
311 else if ((active0 & 0x800000000000000L) != 0x0L)
312 return jjStopAtPos(1, 59);
313 else if ((active0 & 0x1000000000000000L) != 0x0L)
314 return jjStopAtPos(1, 60);
315 else if ((active0 & 0x2000000000000000L) != 0x0L)
316 return jjStopAtPos(1, 61);
317 else if ((active0 & 0x4000000000000000L) != 0x0L)
318 return jjStopAtPos(1, 62);
319 return jjMoveStringLiteralDfa2_0(active0, 0x1800000000000L, active1, 0x0L);
320 case '>':
321 if ((active1 & 0x10000L) != 0x0L)
322 {
323 jjmatchedKind = 80;
324 jjmatchedPos = 1;
325 }
326 else if ((active1 & 0x400000L) != 0x0L)
327 return jjStopAtPos(1, 86);
328 else if ((active1 & 0x800000L) != 0x0L)
329 return jjStopAtPos(1, 87);
330 return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x8003L);
331 case '?':
332 if ((active0 & 0x20000000L) != 0x0L)
333 return jjStopAtPos(1, 29);
334 break;
335 case '[':
336 if ((active0 & 0x80000L) != 0x0L)
337 return jjStopAtPos(1, 19);
338 break;
339 case '^':
340 if ((active0 & 0x80000000000L) != 0x0L)
341 return jjStopAtPos(1, 43);
342 else if ((active0 & 0x200000000000L) != 0x0L)
343 return jjStopAtPos(1, 45);
344 break;
345 case 'a':
346 return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0x942000000000L);
347 case 'e':
348 return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x204600000000L);
349 case 'f':
350 if ((active1 & 0x2000000L) != 0x0L)
351 return jjStartNfaWithStates_0(1, 89, 74);
352 break;
353 case 'h':
354 return jjMoveStringLiteralDfa2_0(active0, 0x200L, active1, 0x10000000L);
355 case 'i':
356 return jjMoveStringLiteralDfa2_0(active0, 0x100001000L, active1, 0x800100000L);
357 case 'l':
358 return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x4000000L);
359 case 'm':
360 return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x401000000000L);
361 case 'n':
362 return jjMoveStringLiteralDfa2_0(active0, 0x200002000L, active1, 0x0L);
363 case 'o':
364 if ((active1 & 0x8000000L) != 0x0L)
365 return jjStartNfaWithStates_0(1, 91, 74);
366 return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x80a0280000L);
367 case 'p':
368 return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x1000000L);
369 case 'r':
370 if ((active0 & 0x400000000L) != 0x0L)
371 return jjStartNfaWithStates_0(1, 34, 74);
372 return jjMoveStringLiteralDfa2_0(active0, 0x400L, active1, 0x20040000000L);
373 case 'u':
374 return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x10100000000L);
375 case 'w':
376 return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x80000000000L);
377 case '|':
378 if ((active0 & 0x80000000L) != 0x0L)
379 return jjStopAtPos(1, 31);
380 break;
381 case '~':
382 if ((active0 & 0x20000000000L) != 0x0L)
383 return jjStopAtPos(1, 41);
384 else if ((active0 & 0x40000000000L) != 0x0L)
385 return jjStopAtPos(1, 42);
386 break;
387 default :
388 break;
389 }
390 return jjStartNfa_0(0, active0, active1);
391 }
392 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1){
393 if (((active0 &= old0) | (active1 &= old1)) == 0L)
394 return jjStartNfa_0(0, old0, old1);
395 try { curChar = input_stream.readChar(); }
396 catch(java.io.IOException e) {
397 jjStopStringLiteralDfa_0(1, active0, active1);
398 return 2;
399 }
400 switch(curChar)
401 {
402 case '.':
403 if ((active0 & 0x4000000L) != 0x0L)
404 return jjStopAtPos(2, 26);
405 break;
406 case '=':
407 if ((active0 & 0x800000000000L) != 0x0L)
408 return jjStopAtPos(2, 47);
409 else if ((active0 & 0x1000000000000L) != 0x0L)
410 return jjStopAtPos(2, 48);
411 else if ((active0 & 0x8000000000000000L) != 0x0L)
412 return jjStopAtPos(2, 63);
413 else if ((active1 & 0x2L) != 0x0L)
414 return jjStopAtPos(2, 65);
415 break;
416 case '>':
417 if ((active1 & 0x8000L) != 0x0L)
418 {
419 jjmatchedKind = 79;
420 jjmatchedPos = 2;
421 }
422 return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x1L);
423 case 'N':
424 if ((active1 & 0x800000000000L) != 0x0L)
425 return jjStartNfaWithStates_0(2, 111, 74);
426 break;
427 case 'd':
428 if ((active0 & 0x200000000L) != 0x0L)
429 return jjStartNfaWithStates_0(2, 33, 74);
430 else if ((active1 & 0x200000L) != 0x0L)
431 return jjStartNfaWithStates_0(2, 85, 74);
432 break;
433 case 'e':
434 return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x40000000L);
435 case 'f':
436 return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x200000000000L);
437 case 'i':
438 return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x80010000000L);
439 case 'l':
440 return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x50000000000L);
441 case 'n':
442 return jjMoveStringLiteralDfa3_0(active0, 0x100001000L, active1, 0x8180000000L);
443 case 'p':
444 return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x401000000000L);
445 case 'r':
446 if ((active1 & 0x20000000L) != 0x0L)
447 return jjStartNfaWithStates_0(2, 93, 74);
448 else if ((active1 & 0x2000000000L) != 0x0L)
449 return jjStartNfaWithStates_0(2, 101, 74);
450 return jjMoveStringLiteralDfa3_0(active0, 0x200L, active1, 0x1000000L);
451 case 's':
452 return jjMoveStringLiteralDfa3_0(active0, 0x2000L, active1, 0x100004000000L);
453 case 't':
454 if ((active1 & 0x80000L) != 0x0L)
455 return jjStartNfaWithStates_0(2, 83, 74);
456 else if ((active1 & 0x4000000000L) != 0x0L)
457 return jjStartNfaWithStates_0(2, 102, 74);
458 return jjMoveStringLiteralDfa3_0(active0, 0x800L, active1, 0x200000000L);
459 case 'u':
460 return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x20000000000L);
461 case 'v':
462 if ((active1 & 0x100000L) != 0x0L)
463 return jjStartNfaWithStates_0(2, 84, 74);
464 break;
465 case 'w':
466 if ((active1 & 0x400000000L) != 0x0L)
467 return jjStartNfaWithStates_0(2, 98, 74);
468 break;
469 case 'y':
470 if ((active0 & 0x400L) != 0x0L)
471 return jjStartNfaWithStates_0(2, 10, 74);
472 break;
473 case 'z':
474 return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x800000000L);
475 default :
476 break;
477 }
478 return jjStartNfa_0(1, active0, active1);
479 }
480 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1){
481 if (((active0 &= old0) | (active1 &= old1)) == 0L)
482 return jjStartNfa_0(1, old0, old1);
483 try { curChar = input_stream.readChar(); }
484 catch(java.io.IOException e) {
485 jjStopStringLiteralDfa_0(2, active0, active1);
486 return 3;
487 }
488 switch(curChar)
489 {
490 case '=':
491 if ((active1 & 0x1L) != 0x0L)
492 return jjStopAtPos(3, 64);
493 break;
494 case 'a':
495 return jjMoveStringLiteralDfa4_0(active0, 0x1000L, active1, 0x200041000000L);
496 case 'c':
497 return jjMoveStringLiteralDfa4_0(active0, 0x800L, active1, 0x100000000L);
498 case 'e':
499 if ((active1 & 0x4000000L) != 0x0L)
500 return jjStartNfaWithStates_0(3, 90, 74);
501 else if ((active1 & 0x800000000L) != 0x0L)
502 return jjStartNfaWithStates_0(3, 99, 74);
503 else if ((active1 & 0x20000000000L) != 0x0L)
504 return jjStartNfaWithStates_0(3, 105, 74);
505 else if ((active1 & 0x100000000000L) != 0x0L)
506 return jjStartNfaWithStates_0(3, 108, 74);
507 break;
508 case 'l':
509 if ((active1 & 0x10000000000L) != 0x0L)
510 return jjStartNfaWithStates_0(3, 104, 74);
511 return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x10000000L);
512 case 'o':
513 return jjMoveStringLiteralDfa4_0(active0, 0x200L, active1, 0x400000000000L);
514 case 's':
515 return jjMoveStringLiteralDfa4_0(active0, 0x100000000L, active1, 0x48000000000L);
516 case 't':
517 return jjMoveStringLiteralDfa4_0(active0, 0x2000L, active1, 0x81080000000L);
518 case 'u':
519 return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x200000000L);
520 default :
521 break;
522 }
523 return jjStartNfa_0(2, active0, active1);
524 }
525 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1){
526 if (((active0 &= old0) | (active1 &= old1)) == 0L)
527 return jjStartNfa_0(2, old0, old1);
528 try { curChar = input_stream.readChar(); }
529 catch(java.io.IOException e) {
530 jjStopStringLiteralDfa_0(3, active0, active1);
531 return 4;
532 }
533 switch(curChar)
534 {
535 case 'a':
536 return jjMoveStringLiteralDfa5_0(active0, 0x2000L, active1, 0x0L);
537 case 'c':
538 return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x80000000000L);
539 case 'e':
540 if ((active1 & 0x10000000L) != 0x0L)
541 return jjStartNfaWithStates_0(4, 92, 74);
542 else if ((active1 & 0x40000000000L) != 0x0L)
543 return jjStartNfaWithStates_0(4, 106, 74);
544 break;
545 case 'g':
546 return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x1000000L);
547 case 'h':
548 if ((active0 & 0x800L) != 0x0L)
549 return jjStartNfaWithStates_0(4, 11, 74);
550 break;
551 case 'i':
552 return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x80000000L);
553 case 'k':
554 if ((active1 & 0x40000000L) != 0x0L)
555 return jjStartNfaWithStates_0(4, 94, 74);
556 break;
557 case 'l':
558 return jjMoveStringLiteralDfa5_0(active0, 0x1000L, active1, 0x0L);
559 case 'r':
560 return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x400200000000L);
561 case 't':
562 if ((active1 & 0x8000000000L) != 0x0L)
563 return jjStartNfaWithStates_0(4, 103, 74);
564 return jjMoveStringLiteralDfa5_0(active0, 0x100000000L, active1, 0x100000000L);
565 case 'u':
566 return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x200000000000L);
567 case 'w':
568 if ((active0 & 0x200L) != 0x0L)
569 return jjStartNfaWithStates_0(4, 9, 74);
570 break;
571 case 'y':
572 if ((active1 & 0x1000000000L) != 0x0L)
573 return jjStartNfaWithStates_0(4, 100, 74);
574 break;
575 default :
576 break;
577 }
578 return jjStartNfa_0(3, active0, active1);
579 }
580 private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1){
581 if (((active0 &= old0) | (active1 &= old1)) == 0L)
582 return jjStartNfa_0(3, old0, old1);
583 try { curChar = input_stream.readChar(); }
584 catch(java.io.IOException e) {
585 jjStopStringLiteralDfa_0(4, active0, active1);
586 return 5;
587 }
588 switch(curChar)
589 {
590 case 'a':
591 return jjMoveStringLiteralDfa6_0(active0, 0x100000000L, active1, 0x0L);
592 case 'h':
593 if ((active1 & 0x80000000000L) != 0x0L)
594 return jjStartNfaWithStates_0(5, 107, 74);
595 break;
596 case 'i':
597 return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x100000000L);
598 case 'l':
599 return jjMoveStringLiteralDfa6_0(active0, 0x1000L, active1, 0x200000000000L);
600 case 'm':
601 return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x1000000L);
602 case 'n':
603 if ((active1 & 0x200000000L) != 0x0L)
604 return jjStartNfaWithStates_0(5, 97, 74);
605 return jjMoveStringLiteralDfa6_0(active0, 0x2000L, active1, 0x80000000L);
606 case 't':
607 if ((active1 & 0x400000000000L) != 0x0L)
608 return jjStartNfaWithStates_0(5, 110, 74);
609 break;
610 default :
611 break;
612 }
613 return jjStartNfa_0(4, active0, active1);
614 }
615 private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1){
616 if (((active0 &= old0) | (active1 &= old1)) == 0L)
617 return jjStartNfa_0(4, old0, old1);
618 try { curChar = input_stream.readChar(); }
619 catch(java.io.IOException e) {
620 jjStopStringLiteralDfa_0(5, active0, active1);
621 return 6;
622 }
623 switch(curChar)
624 {
625 case 'a':
626 if ((active1 & 0x1000000L) != 0x0L)
627 return jjStopAtPos(6, 88);
628 break;
629 case 'c':
630 return jjMoveStringLiteralDfa7_0(active0, 0x2000L, active1, 0x0L);
631 case 'n':
632 return jjMoveStringLiteralDfa7_0(active0, 0x100000000L, active1, 0x0L);
633 case 'o':
634 return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x100000000L);
635 case 't':
636 if ((active1 & 0x200000000000L) != 0x0L)
637 return jjStartNfaWithStates_0(6, 109, 74);
638 break;
639 case 'u':
640 return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x80000000L);
641 case 'y':
642 if ((active0 & 0x1000L) != 0x0L)
643 return jjStartNfaWithStates_0(6, 12, 74);
644 break;
645 default :
646 break;
647 }
648 return jjStartNfa_0(5, active0, active1);
649 }
650 private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1){
651 if (((active0 &= old0) | (active1 &= old1)) == 0L)
652 return jjStartNfa_0(5, old0, old1);
653 try { curChar = input_stream.readChar(); }
654 catch(java.io.IOException e) {
655 jjStopStringLiteralDfa_0(6, active0, active1);
656 return 7;
657 }
658 switch(curChar)
659 {
660 case 'c':
661 return jjMoveStringLiteralDfa8_0(active0, 0x100000000L, active1, 0x0L);
662 case 'e':
663 if ((active1 & 0x80000000L) != 0x0L)
664 return jjStartNfaWithStates_0(7, 95, 74);
665 return jjMoveStringLiteralDfa8_0(active0, 0x2000L, active1, 0x0L);
666 case 'n':
667 if ((active1 & 0x100000000L) != 0x0L)
668 return jjStartNfaWithStates_0(7, 96, 74);
669 break;
670 default :
671 break;
672 }
673 return jjStartNfa_0(6, active0, active1);
674 }
675 private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1){
676 if (((active0 &= old0) | (active1 &= old1)) == 0L)
677 return jjStartNfa_0(6, old0, old1);
678 try { curChar = input_stream.readChar(); }
679 catch(java.io.IOException e) {
680 jjStopStringLiteralDfa_0(7, active0, 0L);
681 return 8;
682 }
683 switch(curChar)
684 {
685 case 'e':
686 return jjMoveStringLiteralDfa9_0(active0, 0x100000000L);
687 case 'o':
688 return jjMoveStringLiteralDfa9_0(active0, 0x2000L);
689 default :
690 break;
691 }
692 return jjStartNfa_0(7, active0, 0L);
693 }
694 private int jjMoveStringLiteralDfa9_0(long old0, long active0){
695 if (((active0 &= old0)) == 0L)
696 return jjStartNfa_0(7, old0, 0L);
697 try { curChar = input_stream.readChar(); }
698 catch(java.io.IOException e) {
699 jjStopStringLiteralDfa_0(8, active0, 0L);
700 return 9;
701 }
702 switch(curChar)
703 {
704 case 'f':
705 if ((active0 & 0x2000L) != 0x0L)
706 return jjStartNfaWithStates_0(9, 13, 74);
707 break;
708 case 'o':
709 return jjMoveStringLiteralDfa10_0(active0, 0x100000000L);
710 default :
711 break;
712 }
713 return jjStartNfa_0(8, active0, 0L);
714 }
715 private int jjMoveStringLiteralDfa10_0(long old0, long active0){
716 if (((active0 &= old0)) == 0L)
717 return jjStartNfa_0(8, old0, 0L);
718 try { curChar = input_stream.readChar(); }
719 catch(java.io.IOException e) {
720 jjStopStringLiteralDfa_0(9, active0, 0L);
721 return 10;
722 }
723 switch(curChar)
724 {
725 case 'f':
726 if ((active0 & 0x100000000L) != 0x0L)
727 return jjStopAtPos(10, 32);
728 break;
729 default :
730 break;
731 }
732 return jjStartNfa_0(9, active0, 0L);
733 }
734 private int jjStartNfaWithStates_0(int pos, int kind, int state)
735 {
736 jjmatchedKind = kind;
737 jjmatchedPos = pos;
738 try { curChar = input_stream.readChar(); }
739 catch(java.io.IOException e) { return pos + 1; }
740 return jjMoveNfa_0(state, pos + 1);
741 }
742 static final long[] jjbitVec0 = {
743 0xfffffffefffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
744 };
745 static final long[] jjbitVec2 = {
746 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
747 };
748 static final long[] jjbitVec3 = {
749 0xfffffcffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
750 };
751 static final long[] jjbitVec4 = {
752 0xffff80ffffffffffL, 0xfffffc3fffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
753 };
754 static final long[] jjbitVec5 = {
755 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
756 };
757 private int jjMoveNfa_0(int startState, int curPos)
758 {
759 int startsAt = 0;
760 jjnewStateCnt = 74;
761 int i = 1;
762 jjstateSet[0] = startState;
763 int kind = 0x7fffffff;
764 for (;;)
765 {
766 if (++jjround == 0x7fffffff)
767 ReInitRounds();
768 if (curChar < 64)
769 {
770 long l = 1L << curChar;
771 do
772 {
773 switch(jjstateSet[--i])
774 {
775 case 0:
776 if ((0x3ff000000000000L & l) != 0x0L)
777 { jjCheckNAddStates(0, 5); }
778 else if (curChar == 47)
779 { jjAddStates(6, 7); }
780 else if (curChar == 35)
781 { jjAddStates(8, 9); }
782 else if (curChar == 39)
783 { jjCheckNAddStates(10, 12); }
784 else if (curChar == 34)
785 { jjCheckNAddStates(13, 15); }
786 else if (curChar == 46)
787 { jjCheckNAdd(12); }
788 else if (curChar == 36)
789 {
790 if (kind > 114)
791 kind = 114;
792 { jjCheckNAddTwoStates(3, 4); }
793 }
794 if ((0x3fe000000000000L & l) != 0x0L)
795 {
796 if (kind > 119)
797 kind = 119;
798 { jjCheckNAddTwoStates(9, 10); }
799 }
800 else if (curChar == 48)
801 {
802 if (kind > 119)
803 kind = 119;
804 { jjCheckNAddStates(16, 18); }
805 }
806 else if (curChar == 35)
807 { jjCheckNAdd(7); }
808 break;
809 case 63:
810 if (curChar == 47)
811 {
812 if (kind > 8)
813 kind = 8;
814 { jjCheckNAddStates(19, 21); }
815 }
816 else if (curChar == 42)
817 { jjCheckNAddTwoStates(64, 65); }
818 break;
819 case 54:
820 if ((0x3ff000000000000L & l) != 0x0L)
821 {
822 if (kind > 118)
823 kind = 118;
824 { jjCheckNAdd(7); }
825 }
826 else if (curChar == 35)
827 {
828 if (kind > 6)
829 kind = 6;
830 { jjCheckNAddStates(22, 24); }
831 }
832 break;
833 case 74:
834 case 3:
835 if ((0x3ff001000000000L & l) == 0x0L)
836 break;
837 if (kind > 114)
838 kind = 114;
839 { jjCheckNAddTwoStates(3, 4); }
840 break;
841 case 1:
842 if ((0x3ff001000000000L & l) == 0x0L)
843 break;
844 if (kind > 112)
845 kind = 112;
846 jjstateSet[jjnewStateCnt++] = 1;
847 break;
848 case 2:
849 if (curChar != 36)
850 break;
851 if (kind > 114)
852 kind = 114;
853 { jjCheckNAddTwoStates(3, 4); }
854 break;
855 case 5:
856 if ((0x8500000000L & l) == 0x0L)
857 break;
858 if (kind > 114)
859 kind = 114;
860 { jjCheckNAddTwoStates(3, 4); }
861 break;
862 case 6:
863 if (curChar == 35)
864 { jjCheckNAdd(7); }
865 break;
866 case 7:
867 if ((0x3ff000000000000L & l) == 0x0L)
868 break;
869 if (kind > 118)
870 kind = 118;
871 { jjCheckNAdd(7); }
872 break;
873 case 8:
874 if ((0x3fe000000000000L & l) == 0x0L)
875 break;
876 if (kind > 119)
877 kind = 119;
878 { jjCheckNAddTwoStates(9, 10); }
879 break;
880 case 9:
881 if ((0x3ff000000000000L & l) == 0x0L)
882 break;
883 if (kind > 119)
884 kind = 119;
885 { jjCheckNAddTwoStates(9, 10); }
886 break;
887 case 11:
888 if (curChar == 46)
889 { jjCheckNAdd(12); }
890 break;
891 case 12:
892 if ((0x3ff000000000000L & l) != 0x0L)
893 { jjCheckNAddStates(25, 27); }
894 break;
895 case 14:
896 if ((0x280000000000L & l) != 0x0L)
897 { jjCheckNAdd(15); }
898 break;
899 case 15:
900 if ((0x3ff000000000000L & l) == 0x0L)
901 break;
902 if (kind > 124)
903 kind = 124;
904 { jjCheckNAddTwoStates(15, 16); }
905 break;
906 case 17:
907 if (curChar == 34)
908 { jjCheckNAddStates(13, 15); }
909 break;
910 case 18:
911 if ((0xfffffffbffffdbffL & l) != 0x0L)
912 { jjCheckNAddStates(13, 15); }
913 break;
914 case 20:
915 if ((0xffffffffffffdbffL & l) != 0x0L)
916 { jjCheckNAddStates(13, 15); }
917 break;
918 case 21:
919 if (curChar == 34 && kind > 128)
920 kind = 128;
921 break;
922 case 22:
923 if (curChar == 39)
924 { jjCheckNAddStates(10, 12); }
925 break;
926 case 23:
927 if ((0xffffff7fffffdbffL & l) != 0x0L)
928 { jjCheckNAddStates(10, 12); }
929 break;
930 case 25:
931 if ((0xffffffffffffdbffL & l) != 0x0L)
932 { jjCheckNAddStates(10, 12); }
933 break;
934 case 26:
935 if (curChar == 39 && kind > 128)
936 kind = 128;
937 break;
938 case 28:
939 { jjCheckNAddStates(28, 30); }
940 break;
941 case 30:
942 if ((0xfffffffffffffffeL & l) != 0x0L)
943 { jjCheckNAddStates(28, 30); }
944 break;
945 case 33:
946 if (curChar == 47)
947 { jjCheckNAddStates(31, 33); }
948 break;
949 case 34:
950 if ((0xffff7fffffffc8ffL & l) != 0x0L)
951 { jjCheckNAddStates(31, 33); }
952 break;
953 case 36:
954 if (curChar == 47 && kind > 130)
955 kind = 130;
956 break;
957 case 37:
958 if ((0x3ff000000000000L & l) != 0x0L)
959 { jjCheckNAddStates(0, 5); }
960 break;
961 case 38:
962 if ((0x3ff000000000000L & l) != 0x0L)
963 { jjCheckNAddTwoStates(38, 39); }
964 break;
965 case 39:
966 if (curChar == 46)
967 { jjCheckNAdd(40); }
968 break;
969 case 40:
970 if ((0x3ff000000000000L & l) == 0x0L)
971 break;
972 if (kind > 124)
973 kind = 124;
974 { jjCheckNAddStates(34, 36); }
975 break;
976 case 42:
977 if ((0x280000000000L & l) != 0x0L)
978 { jjCheckNAdd(43); }
979 break;
980 case 43:
981 if ((0x3ff000000000000L & l) == 0x0L)
982 break;
983 if (kind > 124)
984 kind = 124;
985 { jjCheckNAddTwoStates(43, 16); }
986 break;
987 case 44:
988 if ((0x3ff000000000000L & l) != 0x0L)
989 { jjCheckNAddStates(37, 40); }
990 break;
991 case 45:
992 if (curChar == 46)
993 { jjCheckNAddTwoStates(46, 16); }
994 break;
995 case 47:
996 if ((0x280000000000L & l) != 0x0L)
997 { jjCheckNAdd(48); }
998 break;
999 case 48:
1000 if ((0x3ff000000000000L & l) == 0x0L)
1001 break;
1002 if (kind > 124)
1003 kind = 124;
1004 { jjCheckNAddTwoStates(48, 16); }
1005 break;
1006 case 49:
1007 if (curChar != 48)
1008 break;
1009 if (kind > 119)
1010 kind = 119;
1011 { jjCheckNAddStates(16, 18); }
1012 break;
1013 case 51:
1014 if ((0x3ff000000000000L & l) == 0x0L)
1015 break;
1016 if (kind > 119)
1017 kind = 119;
1018 { jjCheckNAddTwoStates(51, 10); }
1019 break;
1020 case 52:
1021 if ((0xff000000000000L & l) == 0x0L)
1022 break;
1023 if (kind > 119)
1024 kind = 119;
1025 { jjCheckNAddTwoStates(52, 10); }
1026 break;
1027 case 53:
1028 if (curChar == 35)
1029 { jjAddStates(8, 9); }
1030 break;
1031 case 55:
1032 if ((0xffffffffffffdbffL & l) == 0x0L)
1033 break;
1034 if (kind > 6)
1035 kind = 6;
1036 { jjCheckNAddStates(22, 24); }
1037 break;
1038 case 56:
1039 if ((0x2400L & l) != 0x0L && kind > 6)
1040 kind = 6;
1041 break;
1042 case 57:
1043 if (curChar == 10 && kind > 6)
1044 kind = 6;
1045 break;
1046 case 58:
1047 if (curChar == 13)
1048 jjstateSet[jjnewStateCnt++] = 57;
1049 break;
1050 case 62:
1051 if (curChar == 47)
1052 { jjAddStates(6, 7); }
1053 break;
1054 case 64:
1055 if ((0xfffffbffffffffffL & l) != 0x0L)
1056 { jjCheckNAddTwoStates(64, 65); }
1057 break;
1058 case 65:
1059 if (curChar == 42)
1060 { jjCheckNAddStates(41, 43); }
1061 break;
1062 case 66:
1063 if ((0xffff7bffffffffffL & l) != 0x0L)
1064 { jjCheckNAddTwoStates(67, 65); }
1065 break;
1066 case 67:
1067 if ((0xfffffbffffffffffL & l) != 0x0L)
1068 { jjCheckNAddTwoStates(67, 65); }
1069 break;
1070 case 68:
1071 if (curChar == 47 && kind > 7)
1072 kind = 7;
1073 break;
1074 case 69:
1075 if (curChar != 47)
1076 break;
1077 if (kind > 8)
1078 kind = 8;
1079 { jjCheckNAddStates(19, 21); }
1080 break;
1081 case 70:
1082 if ((0xffffffffffffdbffL & l) == 0x0L)
1083 break;
1084 if (kind > 8)
1085 kind = 8;
1086 { jjCheckNAddStates(19, 21); }
1087 break;
1088 case 71:
1089 if ((0x2400L & l) != 0x0L && kind > 8)
1090 kind = 8;
1091 break;
1092 case 72:
1093 if (curChar == 10 && kind > 8)
1094 kind = 8;
1095 break;
1096 case 73:
1097 if (curChar == 13)
1098 jjstateSet[jjnewStateCnt++] = 72;
1099 break;
1100 default : break;
1101 }
1102 } while(i != startsAt);
1103 }
1104 else if (curChar < 128)
1105 {
1106 long l = 1L << (curChar & 077);
1107 do
1108 {
1109 switch(jjstateSet[--i])
1110 {
1111 case 0:
1112 if ((0x7fffffe87ffffffL & l) != 0x0L)
1113 {
1114 if (kind > 114)
1115 kind = 114;
1116 { jjCheckNAddTwoStates(3, 4); }
1117 }
1118 else if (curChar == 126)
1119 { jjCheckNAdd(33); }
1120 else if (curChar == 96)
1121 { jjCheckNAddStates(28, 30); }
1122 if (curChar == 64)
1123 { jjCheckNAdd(1); }
1124 break;
1125 case 54:
1126 if (curChar == 78)
1127 jjstateSet[jjnewStateCnt++] = 60;
1128 break;
1129 case 74:
1130 if ((0x7fffffe87ffffffL & l) != 0x0L)
1131 {
1132 if (kind > 114)
1133 kind = 114;
1134 { jjCheckNAddTwoStates(3, 4); }
1135 }
1136 else if (curChar == 92)
1137 jjstateSet[jjnewStateCnt++] = 5;
1138 break;
1139 case 1:
1140 if ((0x7fffffe87fffffeL & l) == 0x0L)
1141 break;
1142 if (kind > 112)
1143 kind = 112;
1144 { jjCheckNAdd(1); }
1145 break;
1146 case 2:
1147 if ((0x7fffffe87ffffffL & l) == 0x0L)
1148 break;
1149 if (kind > 114)
1150 kind = 114;
1151 { jjCheckNAddTwoStates(3, 4); }
1152 break;
1153 case 3:
1154 if ((0x7fffffe87ffffffL & l) == 0x0L)
1155 break;
1156 if (kind > 114)
1157 kind = 114;
1158 { jjCheckNAddTwoStates(3, 4); }
1159 break;
1160 case 4:
1161 if (curChar == 92)
1162 jjstateSet[jjnewStateCnt++] = 5;
1163 break;
1164 case 5:
1165 if (curChar != 92)
1166 break;
1167 if (kind > 114)
1168 kind = 114;
1169 { jjCheckNAddTwoStates(3, 4); }
1170 break;
1171 case 10:
1172 if ((0x110000001100L & l) != 0x0L && kind > 119)
1173 kind = 119;
1174 break;
1175 case 13:
1176 if ((0x2000000020L & l) != 0x0L)
1177 { jjAddStates(44, 45); }
1178 break;
1179 case 16:
1180 if ((0x5400000054L & l) != 0x0L && kind > 124)
1181 kind = 124;
1182 break;
1183 case 18:
1184 if ((0xffffffffefffffffL & l) != 0x0L)
1185 { jjCheckNAddStates(13, 15); }
1186 break;
1187 case 19:
1188 if (curChar == 92)
1189 jjstateSet[jjnewStateCnt++] = 20;
1190 break;
1191 case 20:
1192 { jjCheckNAddStates(13, 15); }
1193 break;
1194 case 23:
1195 if ((0xffffffffefffffffL & l) != 0x0L)
1196 { jjCheckNAddStates(10, 12); }
1197 break;
1198 case 24:
1199 if (curChar == 92)
1200 jjstateSet[jjnewStateCnt++] = 25;
1201 break;
1202 case 25:
1203 { jjCheckNAddStates(10, 12); }
1204 break;
1205 case 27:
1206 if (curChar == 96)
1207 { jjCheckNAddStates(28, 30); }
1208 break;
1209 case 28:
1210 if ((0xfffffffeefffffffL & l) != 0x0L)
1211 { jjCheckNAddStates(28, 30); }
1212 break;
1213 case 29:
1214 if (curChar == 92)
1215 jjstateSet[jjnewStateCnt++] = 30;
1216 break;
1217 case 30:
1218 { jjCheckNAddStates(28, 30); }
1219 break;
1220 case 31:
1221 if (curChar == 96 && kind > 129)
1222 kind = 129;
1223 break;
1224 case 32:
1225 if (curChar == 126)
1226 { jjCheckNAdd(33); }
1227 break;
1228 case 34:
1229 { jjAddStates(31, 33); }
1230 break;
1231 case 35:
1232 if (curChar == 92)
1233 { jjCheckNAdd(33); }
1234 break;
1235 case 41:
1236 if ((0x2000000020L & l) != 0x0L)
1237 { jjAddStates(46, 47); }
1238 break;
1239 case 46:
1240 if ((0x2000000020L & l) != 0x0L)
1241 { jjAddStates(48, 49); }
1242 break;
1243 case 50:
1244 if ((0x100000001000000L & l) != 0x0L)
1245 { jjCheckNAdd(51); }
1246 break;
1247 case 51:
1248 if ((0x7e0000007eL & l) == 0x0L)
1249 break;
1250 if (kind > 119)
1251 kind = 119;
1252 { jjCheckNAddTwoStates(51, 10); }
1253 break;
1254 case 55:
1255 if (kind > 6)
1256 kind = 6;
1257 { jjAddStates(22, 24); }
1258 break;
1259 case 59:
1260 if (curChar == 78 && kind > 124)
1261 kind = 124;
1262 break;
1263 case 60:
1264 if (curChar == 97)
1265 jjstateSet[jjnewStateCnt++] = 59;
1266 break;
1267 case 64:
1268 { jjCheckNAddTwoStates(64, 65); }
1269 break;
1270 case 66:
1271 case 67:
1272 { jjCheckNAddTwoStates(67, 65); }
1273 break;
1274 case 70:
1275 if (kind > 8)
1276 kind = 8;
1277 { jjAddStates(19, 21); }
1278 break;
1279 default : break;
1280 }
1281 } while(i != startsAt);
1282 }
1283 else
1284 {
1285 int hiByte = (curChar >> 8);
1286 int i1 = hiByte >> 6;
1287 long l1 = 1L << (hiByte & 077);
1288 int i2 = (curChar & 0xff) >> 6;
1289 long l2 = 1L << (curChar & 077);
1290 do
1291 {
1292 switch(jjstateSet[--i])
1293 {
1294 case 18:
1295 case 20:
1296 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1297 { jjCheckNAddStates(13, 15); }
1298 break;
1299 case 23:
1300 case 25:
1301 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1302 { jjCheckNAddStates(10, 12); }
1303 break;
1304 case 28:
1305 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1306 { jjCheckNAddStates(28, 30); }
1307 break;
1308 case 30:
1309 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1310 { jjCheckNAddStates(28, 30); }
1311 break;
1312 case 34:
1313 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1314 { jjAddStates(31, 33); }
1315 break;
1316 case 55:
1317 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1318 break;
1319 if (kind > 6)
1320 kind = 6;
1321 { jjAddStates(22, 24); }
1322 break;
1323 case 64:
1324 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1325 { jjCheckNAddTwoStates(64, 65); }
1326 break;
1327 case 66:
1328 case 67:
1329 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1330 { jjCheckNAddTwoStates(67, 65); }
1331 break;
1332 case 70:
1333 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1334 break;
1335 if (kind > 8)
1336 kind = 8;
1337 { jjAddStates(19, 21); }
1338 break;
1339 default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break;
1340 }
1341 } while(i != startsAt);
1342 }
1343 if (kind != 0x7fffffff)
1344 {
1345 jjmatchedKind = kind;
1346 jjmatchedPos = curPos;
1347 kind = 0x7fffffff;
1348 }
1349 ++curPos;
1350 i = jjnewStateCnt;
1351 jjnewStateCnt = startsAt;
1352 startsAt = 74 - jjnewStateCnt;
1353 if (i == startsAt)
1354 return curPos;
1355 try { curChar = input_stream.readChar(); }
1356 catch(final java.io.IOException e) { return curPos; }
1357 }
1358 }
1359 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1){
1360 switch (pos)
1361 {
1362 case 0:
1363 if ((active1 & 0x20000L) != 0x0L)
1364 return 22;
1365 if ((active1 & 0x1000000L) != 0x0L)
1366 return 0;
1367 if ((active0 & 0x400000000000000L) != 0x0L || (active1 & 0x100L) != 0x0L)
1368 return 27;
1369 return -1;
1370 default :
1371 return -1;
1372 }
1373 }
1374 private final int jjStartNfa_1(int pos, long active0, long active1){
1375 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
1376 }
1377 private int jjMoveStringLiteralDfa0_1(){
1378 switch(curChar)
1379 {
1380 case '!':
1381 jjmatchedKind = 74;
1382 return jjMoveStringLiteralDfa1_1(0x1641100000000L, 0x0L);
1383 case '#':
1384 return jjMoveStringLiteralDfa1_1(0x0L, 0x1000000L);
1385 case '%':
1386 jjmatchedKind = 73;
1387 return jjMoveStringLiteralDfa1_1(0x800000000000000L, 0x0L);
1388 case '&':
1389 jjmatchedKind = 75;
1390 return jjMoveStringLiteralDfa1_1(0x1000000040000000L, 0x0L);
1391 case '(':
1392 return jjStopAtPos(0, 14);
1393 case ')':
1394 return jjStopAtPos(0, 15);
1395 case '*':
1396 jjmatchedKind = 71;
1397 return jjMoveStringLiteralDfa1_1(0x200000000000000L, 0x0L);
1398 case '+':
1399 jjmatchedKind = 67;
1400 return jjMoveStringLiteralDfa1_1(0x80000000000000L, 0x10L);
1401 case ',':
1402 return jjStopAtPos(0, 23);
1403 case '-':
1404 jjmatchedKind = 69;
1405 return jjMoveStringLiteralDfa1_1(0x100000000000000L, 0x400040L);
1406 case '.':
1407 jjmatchedKind = 24;
1408 return jjMoveStringLiteralDfa1_1(0x4000000L, 0x40000L);
1409 case '/':
1410 jjmatchedKind = 72;
1411 return jjMoveStringLiteralDfa1_1(0x400000000000000L, 0x0L);
1412 case ':':
1413 return jjStopAtPos(0, 22);
1414 case ';':
1415 return jjStopAtPos(0, 21);
1416 case '<':
1417 jjmatchedKind = 39;
1418 return jjMoveStringLiteralDfa1_1(0x8000010000000000L, 0x4000L);
1419 case '=':
1420 jjmatchedKind = 66;
1421 return jjMoveStringLiteralDfa1_1(0x9a0800000000L, 0x800000L);
1422 case '>':
1423 jjmatchedKind = 37;
1424 return jjMoveStringLiteralDfa1_1(0x4000000000L, 0x18003L);
1425 case '?':
1426 jjmatchedKind = 27;
1427 return jjMoveStringLiteralDfa1_1(0x32080000L, 0x0L);
1428 case '[':
1429 return jjStopAtPos(0, 18);
1430 case ']':
1431 return jjStopAtPos(0, 20);
1432 case '^':
1433 jjmatchedKind = 77;
1434 return jjMoveStringLiteralDfa1_1(0x4000000000000000L, 0x0L);
1435 case 'e':
1436 return jjMoveStringLiteralDfa1_1(0x2000000000000L, 0x0L);
1437 case 'g':
1438 return jjMoveStringLiteralDfa1_1(0x18000000000000L, 0x0L);
1439 case 'l':
1440 return jjMoveStringLiteralDfa1_1(0x60000000000000L, 0x0L);
1441 case 'n':
1442 return jjMoveStringLiteralDfa1_1(0x4000000000000L, 0x0L);
1443 case '{':
1444 return jjStopAtPos(0, 16);
1445 case '|':
1446 jjmatchedKind = 76;
1447 return jjMoveStringLiteralDfa1_1(0x2000000080000000L, 0x0L);
1448 case '}':
1449 return jjStopAtPos(0, 17);
1450 case '~':
1451 return jjStartNfaWithStates_1(0, 81, 22);
1452 default :
1453 return jjMoveNfa_1(5, 0);
1454 }
1455 }
1456 private int jjMoveStringLiteralDfa1_1(long active0, long active1){
1457 try { curChar = input_stream.readChar(); }
1458 catch(java.io.IOException e) {
1459 jjStopStringLiteralDfa_1(0, active0, active1);
1460 return 1;
1461 }
1462 switch(curChar)
1463 {
1464 case '$':
1465 if ((active0 & 0x100000000000L) != 0x0L)
1466 return jjStopAtPos(1, 44);
1467 else if ((active0 & 0x400000000000L) != 0x0L)
1468 return jjStopAtPos(1, 46);
1469 break;
1470 case '&':
1471 if ((active0 & 0x40000000L) != 0x0L)
1472 return jjStopAtPos(1, 30);
1473 break;
1474 case '+':
1475 if ((active1 & 0x10L) != 0x0L)
1476 return jjStopAtPos(1, 68);
1477 break;
1478 case '-':
1479 if ((active1 & 0x40L) != 0x0L)
1480 return jjStopAtPos(1, 70);
1481 break;
1482 case '.':
1483 if ((active0 & 0x2000000L) != 0x0L)
1484 return jjStopAtPos(1, 25);
1485 else if ((active1 & 0x40000L) != 0x0L)
1486 {
1487 jjmatchedKind = 82;
1488 jjmatchedPos = 1;
1489 }
1490 return jjMoveStringLiteralDfa2_1(active0, 0x4000000L, active1, 0x0L);
1491 case ':':
1492 if ((active0 & 0x10000000L) != 0x0L)
1493 return jjStopAtPos(1, 28);
1494 break;
1495 case '<':
1496 if ((active1 & 0x4000L) != 0x0L)
1497 {
1498 jjmatchedKind = 78;
1499 jjmatchedPos = 1;
1500 }
1501 return jjMoveStringLiteralDfa2_1(active0, 0x8000000000000000L, active1, 0x0L);
1502 case '=':
1503 if ((active0 & 0x800000000L) != 0x0L)
1504 {
1505 jjmatchedKind = 35;
1506 jjmatchedPos = 1;
1507 }
1508 else if ((active0 & 0x1000000000L) != 0x0L)
1509 {
1510 jjmatchedKind = 36;
1511 jjmatchedPos = 1;
1512 }
1513 else if ((active0 & 0x4000000000L) != 0x0L)
1514 return jjStopAtPos(1, 38);
1515 else if ((active0 & 0x10000000000L) != 0x0L)
1516 return jjStopAtPos(1, 40);
1517 else if ((active0 & 0x80000000000000L) != 0x0L)
1518 return jjStopAtPos(1, 55);
1519 else if ((active0 & 0x100000000000000L) != 0x0L)
1520 return jjStopAtPos(1, 56);
1521 else if ((active0 & 0x200000000000000L) != 0x0L)
1522 return jjStopAtPos(1, 57);
1523 else if ((active0 & 0x400000000000000L) != 0x0L)
1524 return jjStopAtPos(1, 58);
1525 else if ((active0 & 0x800000000000000L) != 0x0L)
1526 return jjStopAtPos(1, 59);
1527 else if ((active0 & 0x1000000000000000L) != 0x0L)
1528 return jjStopAtPos(1, 60);
1529 else if ((active0 & 0x2000000000000000L) != 0x0L)
1530 return jjStopAtPos(1, 61);
1531 else if ((active0 & 0x4000000000000000L) != 0x0L)
1532 return jjStopAtPos(1, 62);
1533 return jjMoveStringLiteralDfa2_1(active0, 0x1800000000000L, active1, 0x0L);
1534 case '>':
1535 if ((active1 & 0x10000L) != 0x0L)
1536 {
1537 jjmatchedKind = 80;
1538 jjmatchedPos = 1;
1539 }
1540 else if ((active1 & 0x400000L) != 0x0L)
1541 return jjStopAtPos(1, 86);
1542 else if ((active1 & 0x800000L) != 0x0L)
1543 return jjStopAtPos(1, 87);
1544 return jjMoveStringLiteralDfa2_1(active0, 0x0L, active1, 0x8003L);
1545 case '?':
1546 if ((active0 & 0x20000000L) != 0x0L)
1547 return jjStopAtPos(1, 29);
1548 break;
1549 case '[':
1550 if ((active0 & 0x80000L) != 0x0L)
1551 return jjStopAtPos(1, 19);
1552 break;
1553 case '^':
1554 if ((active0 & 0x80000000000L) != 0x0L)
1555 return jjStopAtPos(1, 43);
1556 else if ((active0 & 0x200000000000L) != 0x0L)
1557 return jjStopAtPos(1, 45);
1558 break;
1559 case 'e':
1560 if ((active0 & 0x4000000000000L) != 0x0L)
1561 return jjStopAtPos(1, 50);
1562 else if ((active0 & 0x10000000000000L) != 0x0L)
1563 return jjStopAtPos(1, 52);
1564 else if ((active0 & 0x40000000000000L) != 0x0L)
1565 return jjStopAtPos(1, 54);
1566 break;
1567 case 'i':
1568 return jjMoveStringLiteralDfa2_1(active0, 0x100000000L, active1, 0x0L);
1569 case 'p':
1570 return jjMoveStringLiteralDfa2_1(active0, 0x0L, active1, 0x1000000L);
1571 case 'q':
1572 if ((active0 & 0x2000000000000L) != 0x0L)
1573 return jjStopAtPos(1, 49);
1574 break;
1575 case 't':
1576 if ((active0 & 0x8000000000000L) != 0x0L)
1577 return jjStopAtPos(1, 51);
1578 else if ((active0 & 0x20000000000000L) != 0x0L)
1579 return jjStopAtPos(1, 53);
1580 break;
1581 case '|':
1582 if ((active0 & 0x80000000L) != 0x0L)
1583 return jjStopAtPos(1, 31);
1584 break;
1585 case '~':
1586 if ((active0 & 0x20000000000L) != 0x0L)
1587 return jjStopAtPos(1, 41);
1588 else if ((active0 & 0x40000000000L) != 0x0L)
1589 return jjStopAtPos(1, 42);
1590 break;
1591 default :
1592 break;
1593 }
1594 return jjStartNfa_1(0, active0, active1);
1595 }
1596 private int jjMoveStringLiteralDfa2_1(long old0, long active0, long old1, long active1){
1597 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1598 return jjStartNfa_1(0, old0, old1);
1599 try { curChar = input_stream.readChar(); }
1600 catch(java.io.IOException e) {
1601 jjStopStringLiteralDfa_1(1, active0, active1);
1602 return 2;
1603 }
1604 switch(curChar)
1605 {
1606 case '.':
1607 if ((active0 & 0x4000000L) != 0x0L)
1608 return jjStopAtPos(2, 26);
1609 break;
1610 case '=':
1611 if ((active0 & 0x800000000000L) != 0x0L)
1612 return jjStopAtPos(2, 47);
1613 else if ((active0 & 0x1000000000000L) != 0x0L)
1614 return jjStopAtPos(2, 48);
1615 else if ((active0 & 0x8000000000000000L) != 0x0L)
1616 return jjStopAtPos(2, 63);
1617 else if ((active1 & 0x2L) != 0x0L)
1618 return jjStopAtPos(2, 65);
1619 break;
1620 case '>':
1621 if ((active1 & 0x8000L) != 0x0L)
1622 {
1623 jjmatchedKind = 79;
1624 jjmatchedPos = 2;
1625 }
1626 return jjMoveStringLiteralDfa3_1(active0, 0x0L, active1, 0x1L);
1627 case 'n':
1628 return jjMoveStringLiteralDfa3_1(active0, 0x100000000L, active1, 0x0L);
1629 case 'r':
1630 return jjMoveStringLiteralDfa3_1(active0, 0x0L, active1, 0x1000000L);
1631 default :
1632 break;
1633 }
1634 return jjStartNfa_1(1, active0, active1);
1635 }
1636 private int jjMoveStringLiteralDfa3_1(long old0, long active0, long old1, long active1){
1637 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1638 return jjStartNfa_1(1, old0, old1);
1639 try { curChar = input_stream.readChar(); }
1640 catch(java.io.IOException e) {
1641 jjStopStringLiteralDfa_1(2, active0, active1);
1642 return 3;
1643 }
1644 switch(curChar)
1645 {
1646 case '=':
1647 if ((active1 & 0x1L) != 0x0L)
1648 return jjStopAtPos(3, 64);
1649 break;
1650 case 'a':
1651 return jjMoveStringLiteralDfa4_1(active0, 0x0L, active1, 0x1000000L);
1652 case 's':
1653 return jjMoveStringLiteralDfa4_1(active0, 0x100000000L, active1, 0x0L);
1654 default :
1655 break;
1656 }
1657 return jjStartNfa_1(2, active0, active1);
1658 }
1659 private int jjMoveStringLiteralDfa4_1(long old0, long active0, long old1, long active1){
1660 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1661 return jjStartNfa_1(2, old0, old1);
1662 try { curChar = input_stream.readChar(); }
1663 catch(java.io.IOException e) {
1664 jjStopStringLiteralDfa_1(3, active0, active1);
1665 return 4;
1666 }
1667 switch(curChar)
1668 {
1669 case 'g':
1670 return jjMoveStringLiteralDfa5_1(active0, 0x0L, active1, 0x1000000L);
1671 case 't':
1672 return jjMoveStringLiteralDfa5_1(active0, 0x100000000L, active1, 0x0L);
1673 default :
1674 break;
1675 }
1676 return jjStartNfa_1(3, active0, active1);
1677 }
1678 private int jjMoveStringLiteralDfa5_1(long old0, long active0, long old1, long active1){
1679 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1680 return jjStartNfa_1(3, old0, old1);
1681 try { curChar = input_stream.readChar(); }
1682 catch(java.io.IOException e) {
1683 jjStopStringLiteralDfa_1(4, active0, active1);
1684 return 5;
1685 }
1686 switch(curChar)
1687 {
1688 case 'a':
1689 return jjMoveStringLiteralDfa6_1(active0, 0x100000000L, active1, 0x0L);
1690 case 'm':
1691 return jjMoveStringLiteralDfa6_1(active0, 0x0L, active1, 0x1000000L);
1692 default :
1693 break;
1694 }
1695 return jjStartNfa_1(4, active0, active1);
1696 }
1697 private int jjMoveStringLiteralDfa6_1(long old0, long active0, long old1, long active1){
1698 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1699 return jjStartNfa_1(4, old0, old1);
1700 try { curChar = input_stream.readChar(); }
1701 catch(java.io.IOException e) {
1702 jjStopStringLiteralDfa_1(5, active0, active1);
1703 return 6;
1704 }
1705 switch(curChar)
1706 {
1707 case 'a':
1708 if ((active1 & 0x1000000L) != 0x0L)
1709 return jjStopAtPos(6, 88);
1710 break;
1711 case 'n':
1712 return jjMoveStringLiteralDfa7_1(active0, 0x100000000L, active1, 0x0L);
1713 default :
1714 break;
1715 }
1716 return jjStartNfa_1(5, active0, active1);
1717 }
1718 private int jjMoveStringLiteralDfa7_1(long old0, long active0, long old1, long active1){
1719 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1720 return jjStartNfa_1(5, old0, old1);
1721 try { curChar = input_stream.readChar(); }
1722 catch(java.io.IOException e) {
1723 jjStopStringLiteralDfa_1(6, active0, 0L);
1724 return 7;
1725 }
1726 switch(curChar)
1727 {
1728 case 'c':
1729 return jjMoveStringLiteralDfa8_1(active0, 0x100000000L);
1730 default :
1731 break;
1732 }
1733 return jjStartNfa_1(6, active0, 0L);
1734 }
1735 private int jjMoveStringLiteralDfa8_1(long old0, long active0){
1736 if (((active0 &= old0)) == 0L)
1737 return jjStartNfa_1(6, old0, 0L);
1738 try { curChar = input_stream.readChar(); }
1739 catch(java.io.IOException e) {
1740 jjStopStringLiteralDfa_1(7, active0, 0L);
1741 return 8;
1742 }
1743 switch(curChar)
1744 {
1745 case 'e':
1746 return jjMoveStringLiteralDfa9_1(active0, 0x100000000L);
1747 default :
1748 break;
1749 }
1750 return jjStartNfa_1(7, active0, 0L);
1751 }
1752 private int jjMoveStringLiteralDfa9_1(long old0, long active0){
1753 if (((active0 &= old0)) == 0L)
1754 return jjStartNfa_1(7, old0, 0L);
1755 try { curChar = input_stream.readChar(); }
1756 catch(java.io.IOException e) {
1757 jjStopStringLiteralDfa_1(8, active0, 0L);
1758 return 9;
1759 }
1760 switch(curChar)
1761 {
1762 case 'o':
1763 return jjMoveStringLiteralDfa10_1(active0, 0x100000000L);
1764 default :
1765 break;
1766 }
1767 return jjStartNfa_1(8, active0, 0L);
1768 }
1769 private int jjMoveStringLiteralDfa10_1(long old0, long active0){
1770 if (((active0 &= old0)) == 0L)
1771 return jjStartNfa_1(8, old0, 0L);
1772 try { curChar = input_stream.readChar(); }
1773 catch(java.io.IOException e) {
1774 jjStopStringLiteralDfa_1(9, active0, 0L);
1775 return 10;
1776 }
1777 switch(curChar)
1778 {
1779 case 'f':
1780 if ((active0 & 0x100000000L) != 0x0L)
1781 return jjStopAtPos(10, 32);
1782 break;
1783 default :
1784 break;
1785 }
1786 return jjStartNfa_1(9, active0, 0L);
1787 }
1788 private int jjStartNfaWithStates_1(int pos, int kind, int state)
1789 {
1790 jjmatchedKind = kind;
1791 jjmatchedPos = pos;
1792 try { curChar = input_stream.readChar(); }
1793 catch(java.io.IOException e) { return pos + 1; }
1794 return jjMoveNfa_1(state, pos + 1);
1795 }
1796 private int jjMoveNfa_1(int startState, int curPos)
1797 {
1798 int startsAt = 0;
1799 jjnewStateCnt = 38;
1800 int i = 1;
1801 jjstateSet[0] = startState;
1802 int kind = 0x7fffffff;
1803 for (;;)
1804 {
1805 if (++jjround == 0x7fffffff)
1806 ReInitRounds();
1807 if (curChar < 64)
1808 {
1809 long l = 1L << curChar;
1810 do
1811 {
1812 switch(jjstateSet[--i])
1813 {
1814 case 27:
1815 if (curChar == 47)
1816 {
1817 if (kind > 8)
1818 kind = 8;
1819 { jjCheckNAddStates(50, 52); }
1820 }
1821 else if (curChar == 42)
1822 { jjCheckNAddTwoStates(28, 29); }
1823 break;
1824 case 5:
1825 if (curChar == 47)
1826 { jjAddStates(53, 54); }
1827 else if (curChar == 39)
1828 { jjCheckNAddStates(55, 57); }
1829 else if (curChar == 34)
1830 { jjCheckNAddStates(58, 60); }
1831 else if (curChar == 35)
1832 jjstateSet[jjnewStateCnt++] = 0;
1833 break;
1834 case 0:
1835 if (curChar != 35)
1836 break;
1837 if (kind > 6)
1838 kind = 6;
1839 { jjCheckNAddStates(61, 63); }
1840 break;
1841 case 1:
1842 if ((0xffffffffffffdbffL & l) == 0x0L)
1843 break;
1844 if (kind > 6)
1845 kind = 6;
1846 { jjCheckNAddStates(61, 63); }
1847 break;
1848 case 2:
1849 if ((0x2400L & l) != 0x0L && kind > 6)
1850 kind = 6;
1851 break;
1852 case 3:
1853 if (curChar == 10 && kind > 6)
1854 kind = 6;
1855 break;
1856 case 4:
1857 if (curChar == 13)
1858 jjstateSet[jjnewStateCnt++] = 3;
1859 break;
1860 case 6:
1861 if (curChar == 34)
1862 { jjCheckNAddStates(58, 60); }
1863 break;
1864 case 7:
1865 if ((0xfffffffbffffdbffL & l) != 0x0L)
1866 { jjCheckNAddStates(58, 60); }
1867 break;
1868 case 9:
1869 if ((0xffffffffffffdbffL & l) != 0x0L)
1870 { jjCheckNAddStates(58, 60); }
1871 break;
1872 case 10:
1873 if (curChar == 34 && kind > 128)
1874 kind = 128;
1875 break;
1876 case 11:
1877 if (curChar == 39)
1878 { jjCheckNAddStates(55, 57); }
1879 break;
1880 case 12:
1881 if ((0xffffff7fffffdbffL & l) != 0x0L)
1882 { jjCheckNAddStates(55, 57); }
1883 break;
1884 case 14:
1885 if ((0xffffffffffffdbffL & l) != 0x0L)
1886 { jjCheckNAddStates(55, 57); }
1887 break;
1888 case 15:
1889 if (curChar == 39 && kind > 128)
1890 kind = 128;
1891 break;
1892 case 17:
1893 { jjCheckNAddStates(64, 66); }
1894 break;
1895 case 19:
1896 if ((0xfffffffffffffffeL & l) != 0x0L)
1897 { jjCheckNAddStates(64, 66); }
1898 break;
1899 case 22:
1900 if (curChar == 47)
1901 { jjCheckNAddStates(67, 69); }
1902 break;
1903 case 23:
1904 if ((0xffff7fffffffc8ffL & l) != 0x0L)
1905 { jjCheckNAddStates(67, 69); }
1906 break;
1907 case 25:
1908 if (curChar == 47 && kind > 130)
1909 kind = 130;
1910 break;
1911 case 26:
1912 if (curChar == 47)
1913 { jjAddStates(53, 54); }
1914 break;
1915 case 28:
1916 if ((0xfffffbffffffffffL & l) != 0x0L)
1917 { jjCheckNAddTwoStates(28, 29); }
1918 break;
1919 case 29:
1920 if (curChar == 42)
1921 { jjCheckNAddStates(70, 72); }
1922 break;
1923 case 30:
1924 if ((0xffff7bffffffffffL & l) != 0x0L)
1925 { jjCheckNAddTwoStates(31, 29); }
1926 break;
1927 case 31:
1928 if ((0xfffffbffffffffffL & l) != 0x0L)
1929 { jjCheckNAddTwoStates(31, 29); }
1930 break;
1931 case 32:
1932 if (curChar == 47 && kind > 7)
1933 kind = 7;
1934 break;
1935 case 33:
1936 if (curChar != 47)
1937 break;
1938 if (kind > 8)
1939 kind = 8;
1940 { jjCheckNAddStates(50, 52); }
1941 break;
1942 case 34:
1943 if ((0xffffffffffffdbffL & l) == 0x0L)
1944 break;
1945 if (kind > 8)
1946 kind = 8;
1947 { jjCheckNAddStates(50, 52); }
1948 break;
1949 case 35:
1950 if ((0x2400L & l) != 0x0L && kind > 8)
1951 kind = 8;
1952 break;
1953 case 36:
1954 if (curChar == 10 && kind > 8)
1955 kind = 8;
1956 break;
1957 case 37:
1958 if (curChar == 13)
1959 jjstateSet[jjnewStateCnt++] = 36;
1960 break;
1961 default : break;
1962 }
1963 } while(i != startsAt);
1964 }
1965 else if (curChar < 128)
1966 {
1967 long l = 1L << (curChar & 077);
1968 do
1969 {
1970 switch(jjstateSet[--i])
1971 {
1972 case 5:
1973 if (curChar == 126)
1974 { jjCheckNAdd(22); }
1975 else if (curChar == 96)
1976 { jjCheckNAddStates(64, 66); }
1977 break;
1978 case 1:
1979 if (kind > 6)
1980 kind = 6;
1981 { jjAddStates(61, 63); }
1982 break;
1983 case 7:
1984 if ((0xffffffffefffffffL & l) != 0x0L)
1985 { jjCheckNAddStates(58, 60); }
1986 break;
1987 case 8:
1988 if (curChar == 92)
1989 jjstateSet[jjnewStateCnt++] = 9;
1990 break;
1991 case 9:
1992 { jjCheckNAddStates(58, 60); }
1993 break;
1994 case 12:
1995 if ((0xffffffffefffffffL & l) != 0x0L)
1996 { jjCheckNAddStates(55, 57); }
1997 break;
1998 case 13:
1999 if (curChar == 92)
2000 jjstateSet[jjnewStateCnt++] = 14;
2001 break;
2002 case 14:
2003 { jjCheckNAddStates(55, 57); }
2004 break;
2005 case 16:
2006 if (curChar == 96)
2007 { jjCheckNAddStates(64, 66); }
2008 break;
2009 case 17:
2010 if ((0xfffffffeefffffffL & l) != 0x0L)
2011 { jjCheckNAddStates(64, 66); }
2012 break;
2013 case 18:
2014 if (curChar == 92)
2015 jjstateSet[jjnewStateCnt++] = 19;
2016 break;
2017 case 19:
2018 { jjCheckNAddStates(64, 66); }
2019 break;
2020 case 20:
2021 if (curChar == 96 && kind > 129)
2022 kind = 129;
2023 break;
2024 case 21:
2025 if (curChar == 126)
2026 { jjCheckNAdd(22); }
2027 break;
2028 case 23:
2029 { jjAddStates(67, 69); }
2030 break;
2031 case 24:
2032 if (curChar == 92)
2033 { jjCheckNAdd(22); }
2034 break;
2035 case 28:
2036 { jjCheckNAddTwoStates(28, 29); }
2037 break;
2038 case 30:
2039 case 31:
2040 { jjCheckNAddTwoStates(31, 29); }
2041 break;
2042 case 34:
2043 if (kind > 8)
2044 kind = 8;
2045 { jjAddStates(50, 52); }
2046 break;
2047 default : break;
2048 }
2049 } while(i != startsAt);
2050 }
2051 else
2052 {
2053 int hiByte = (curChar >> 8);
2054 int i1 = hiByte >> 6;
2055 long l1 = 1L << (hiByte & 077);
2056 int i2 = (curChar & 0xff) >> 6;
2057 long l2 = 1L << (curChar & 077);
2058 do
2059 {
2060 switch(jjstateSet[--i])
2061 {
2062 case 1:
2063 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
2064 break;
2065 if (kind > 6)
2066 kind = 6;
2067 { jjAddStates(61, 63); }
2068 break;
2069 case 7:
2070 case 9:
2071 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2072 { jjCheckNAddStates(58, 60); }
2073 break;
2074 case 12:
2075 case 14:
2076 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2077 { jjCheckNAddStates(55, 57); }
2078 break;
2079 case 17:
2080 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2081 { jjCheckNAddStates(64, 66); }
2082 break;
2083 case 19:
2084 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2085 { jjCheckNAddStates(64, 66); }
2086 break;
2087 case 23:
2088 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2089 { jjAddStates(67, 69); }
2090 break;
2091 case 28:
2092 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2093 { jjCheckNAddTwoStates(28, 29); }
2094 break;
2095 case 30:
2096 case 31:
2097 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2098 { jjCheckNAddTwoStates(31, 29); }
2099 break;
2100 case 34:
2101 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
2102 break;
2103 if (kind > 8)
2104 kind = 8;
2105 { jjAddStates(50, 52); }
2106 break;
2107 default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break;
2108 }
2109 } while(i != startsAt);
2110 }
2111 if (kind != 0x7fffffff)
2112 {
2113 jjmatchedKind = kind;
2114 jjmatchedPos = curPos;
2115 kind = 0x7fffffff;
2116 }
2117 ++curPos;
2118 i = jjnewStateCnt;
2119 jjnewStateCnt = startsAt;
2120 startsAt = 38 - jjnewStateCnt;
2121 if (i == startsAt)
2122 return curPos;
2123 try { curChar = input_stream.readChar(); }
2124 catch(final java.io.IOException e) { return curPos; }
2125 }
2126 }
2127 private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1){
2128 switch (pos)
2129 {
2130 case 0:
2131 if ((active1 & 0x20000L) != 0x0L)
2132 return 23;
2133 if ((active0 & 0x400000000000000L) != 0x0L || (active1 & 0x100L) != 0x0L)
2134 return 28;
2135 if ((active1 & 0x1000000L) != 0x0L)
2136 return 0;
2137 return -1;
2138 default :
2139 return -1;
2140 }
2141 }
2142 private final int jjStartNfa_2(int pos, long active0, long active1){
2143 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
2144 }
2145 private int jjMoveStringLiteralDfa0_2(){
2146 switch(curChar)
2147 {
2148 case '!':
2149 jjmatchedKind = 74;
2150 return jjMoveStringLiteralDfa1_2(0x1641100000000L, 0x0L);
2151 case '#':
2152 return jjMoveStringLiteralDfa1_2(0x0L, 0x1000000L);
2153 case '%':
2154 jjmatchedKind = 73;
2155 return jjMoveStringLiteralDfa1_2(0x800000000000000L, 0x0L);
2156 case '&':
2157 jjmatchedKind = 75;
2158 return jjMoveStringLiteralDfa1_2(0x1000000040000000L, 0x0L);
2159 case '(':
2160 return jjStopAtPos(0, 14);
2161 case ')':
2162 return jjStopAtPos(0, 15);
2163 case '*':
2164 jjmatchedKind = 71;
2165 return jjMoveStringLiteralDfa1_2(0x200000000000000L, 0x0L);
2166 case '+':
2167 jjmatchedKind = 67;
2168 return jjMoveStringLiteralDfa1_2(0x80000000000000L, 0x10L);
2169 case ',':
2170 return jjStopAtPos(0, 23);
2171 case '-':
2172 jjmatchedKind = 69;
2173 return jjMoveStringLiteralDfa1_2(0x100000000000000L, 0x400040L);
2174 case '.':
2175 jjmatchedKind = 24;
2176 return jjMoveStringLiteralDfa1_2(0x4000000L, 0x40000L);
2177 case '/':
2178 jjmatchedKind = 72;
2179 return jjMoveStringLiteralDfa1_2(0x400000000000000L, 0x0L);
2180 case ':':
2181 return jjStopAtPos(0, 22);
2182 case ';':
2183 return jjStopAtPos(0, 21);
2184 case '<':
2185 jjmatchedKind = 39;
2186 return jjMoveStringLiteralDfa1_2(0x8000010000000000L, 0x4000L);
2187 case '=':
2188 jjmatchedKind = 66;
2189 return jjMoveStringLiteralDfa1_2(0x9a0800000000L, 0x800000L);
2190 case '>':
2191 jjmatchedKind = 37;
2192 return jjMoveStringLiteralDfa1_2(0x4000000000L, 0x18003L);
2193 case '?':
2194 jjmatchedKind = 27;
2195 return jjMoveStringLiteralDfa1_2(0x32080000L, 0x0L);
2196 case '[':
2197 return jjStopAtPos(0, 18);
2198 case ']':
2199 return jjStopAtPos(0, 20);
2200 case '^':
2201 jjmatchedKind = 77;
2202 return jjMoveStringLiteralDfa1_2(0x4000000000000000L, 0x0L);
2203 case '{':
2204 return jjStopAtPos(0, 16);
2205 case '|':
2206 jjmatchedKind = 76;
2207 return jjMoveStringLiteralDfa1_2(0x2000000080000000L, 0x0L);
2208 case '}':
2209 return jjStopAtPos(0, 17);
2210 case '~':
2211 return jjStartNfaWithStates_2(0, 81, 23);
2212 default :
2213 return jjMoveNfa_2(5, 0);
2214 }
2215 }
2216 private int jjMoveStringLiteralDfa1_2(long active0, long active1){
2217 try { curChar = input_stream.readChar(); }
2218 catch(java.io.IOException e) {
2219 jjStopStringLiteralDfa_2(0, active0, active1);
2220 return 1;
2221 }
2222 switch(curChar)
2223 {
2224 case '$':
2225 if ((active0 & 0x100000000000L) != 0x0L)
2226 return jjStopAtPos(1, 44);
2227 else if ((active0 & 0x400000000000L) != 0x0L)
2228 return jjStopAtPos(1, 46);
2229 break;
2230 case '&':
2231 if ((active0 & 0x40000000L) != 0x0L)
2232 return jjStopAtPos(1, 30);
2233 break;
2234 case '+':
2235 if ((active1 & 0x10L) != 0x0L)
2236 return jjStopAtPos(1, 68);
2237 break;
2238 case '-':
2239 if ((active1 & 0x40L) != 0x0L)
2240 return jjStopAtPos(1, 70);
2241 break;
2242 case '.':
2243 if ((active0 & 0x2000000L) != 0x0L)
2244 return jjStopAtPos(1, 25);
2245 else if ((active1 & 0x40000L) != 0x0L)
2246 {
2247 jjmatchedKind = 82;
2248 jjmatchedPos = 1;
2249 }
2250 return jjMoveStringLiteralDfa2_2(active0, 0x4000000L, active1, 0x0L);
2251 case ':':
2252 if ((active0 & 0x10000000L) != 0x0L)
2253 return jjStopAtPos(1, 28);
2254 break;
2255 case '<':
2256 if ((active1 & 0x4000L) != 0x0L)
2257 {
2258 jjmatchedKind = 78;
2259 jjmatchedPos = 1;
2260 }
2261 return jjMoveStringLiteralDfa2_2(active0, 0x8000000000000000L, active1, 0x0L);
2262 case '=':
2263 if ((active0 & 0x800000000L) != 0x0L)
2264 {
2265 jjmatchedKind = 35;
2266 jjmatchedPos = 1;
2267 }
2268 else if ((active0 & 0x1000000000L) != 0x0L)
2269 {
2270 jjmatchedKind = 36;
2271 jjmatchedPos = 1;
2272 }
2273 else if ((active0 & 0x4000000000L) != 0x0L)
2274 return jjStopAtPos(1, 38);
2275 else if ((active0 & 0x10000000000L) != 0x0L)
2276 return jjStopAtPos(1, 40);
2277 else if ((active0 & 0x80000000000000L) != 0x0L)
2278 return jjStopAtPos(1, 55);
2279 else if ((active0 & 0x100000000000000L) != 0x0L)
2280 return jjStopAtPos(1, 56);
2281 else if ((active0 & 0x200000000000000L) != 0x0L)
2282 return jjStopAtPos(1, 57);
2283 else if ((active0 & 0x400000000000000L) != 0x0L)
2284 return jjStopAtPos(1, 58);
2285 else if ((active0 & 0x800000000000000L) != 0x0L)
2286 return jjStopAtPos(1, 59);
2287 else if ((active0 & 0x1000000000000000L) != 0x0L)
2288 return jjStopAtPos(1, 60);
2289 else if ((active0 & 0x2000000000000000L) != 0x0L)
2290 return jjStopAtPos(1, 61);
2291 else if ((active0 & 0x4000000000000000L) != 0x0L)
2292 return jjStopAtPos(1, 62);
2293 return jjMoveStringLiteralDfa2_2(active0, 0x1800000000000L, active1, 0x0L);
2294 case '>':
2295 if ((active1 & 0x10000L) != 0x0L)
2296 {
2297 jjmatchedKind = 80;
2298 jjmatchedPos = 1;
2299 }
2300 else if ((active1 & 0x400000L) != 0x0L)
2301 return jjStopAtPos(1, 86);
2302 else if ((active1 & 0x800000L) != 0x0L)
2303 return jjStopAtPos(1, 87);
2304 return jjMoveStringLiteralDfa2_2(active0, 0x0L, active1, 0x8003L);
2305 case '?':
2306 if ((active0 & 0x20000000L) != 0x0L)
2307 return jjStopAtPos(1, 29);
2308 break;
2309 case '[':
2310 if ((active0 & 0x80000L) != 0x0L)
2311 return jjStopAtPos(1, 19);
2312 break;
2313 case '^':
2314 if ((active0 & 0x80000000000L) != 0x0L)
2315 return jjStopAtPos(1, 43);
2316 else if ((active0 & 0x200000000000L) != 0x0L)
2317 return jjStopAtPos(1, 45);
2318 break;
2319 case 'i':
2320 return jjMoveStringLiteralDfa2_2(active0, 0x100000000L, active1, 0x0L);
2321 case 'p':
2322 return jjMoveStringLiteralDfa2_2(active0, 0x0L, active1, 0x1000000L);
2323 case '|':
2324 if ((active0 & 0x80000000L) != 0x0L)
2325 return jjStopAtPos(1, 31);
2326 break;
2327 case '~':
2328 if ((active0 & 0x20000000000L) != 0x0L)
2329 return jjStopAtPos(1, 41);
2330 else if ((active0 & 0x40000000000L) != 0x0L)
2331 return jjStopAtPos(1, 42);
2332 break;
2333 default :
2334 break;
2335 }
2336 return jjStartNfa_2(0, active0, active1);
2337 }
2338 private int jjMoveStringLiteralDfa2_2(long old0, long active0, long old1, long active1){
2339 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2340 return jjStartNfa_2(0, old0, old1);
2341 try { curChar = input_stream.readChar(); }
2342 catch(java.io.IOException e) {
2343 jjStopStringLiteralDfa_2(1, active0, active1);
2344 return 2;
2345 }
2346 switch(curChar)
2347 {
2348 case '.':
2349 if ((active0 & 0x4000000L) != 0x0L)
2350 return jjStopAtPos(2, 26);
2351 break;
2352 case '=':
2353 if ((active0 & 0x800000000000L) != 0x0L)
2354 return jjStopAtPos(2, 47);
2355 else if ((active0 & 0x1000000000000L) != 0x0L)
2356 return jjStopAtPos(2, 48);
2357 else if ((active0 & 0x8000000000000000L) != 0x0L)
2358 return jjStopAtPos(2, 63);
2359 else if ((active1 & 0x2L) != 0x0L)
2360 return jjStopAtPos(2, 65);
2361 break;
2362 case '>':
2363 if ((active1 & 0x8000L) != 0x0L)
2364 {
2365 jjmatchedKind = 79;
2366 jjmatchedPos = 2;
2367 }
2368 return jjMoveStringLiteralDfa3_2(active0, 0x0L, active1, 0x1L);
2369 case 'n':
2370 return jjMoveStringLiteralDfa3_2(active0, 0x100000000L, active1, 0x0L);
2371 case 'r':
2372 return jjMoveStringLiteralDfa3_2(active0, 0x0L, active1, 0x1000000L);
2373 default :
2374 break;
2375 }
2376 return jjStartNfa_2(1, active0, active1);
2377 }
2378 private int jjMoveStringLiteralDfa3_2(long old0, long active0, long old1, long active1){
2379 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2380 return jjStartNfa_2(1, old0, old1);
2381 try { curChar = input_stream.readChar(); }
2382 catch(java.io.IOException e) {
2383 jjStopStringLiteralDfa_2(2, active0, active1);
2384 return 3;
2385 }
2386 switch(curChar)
2387 {
2388 case '=':
2389 if ((active1 & 0x1L) != 0x0L)
2390 return jjStopAtPos(3, 64);
2391 break;
2392 case 'a':
2393 return jjMoveStringLiteralDfa4_2(active0, 0x0L, active1, 0x1000000L);
2394 case 's':
2395 return jjMoveStringLiteralDfa4_2(active0, 0x100000000L, active1, 0x0L);
2396 default :
2397 break;
2398 }
2399 return jjStartNfa_2(2, active0, active1);
2400 }
2401 private int jjMoveStringLiteralDfa4_2(long old0, long active0, long old1, long active1){
2402 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2403 return jjStartNfa_2(2, old0, old1);
2404 try { curChar = input_stream.readChar(); }
2405 catch(java.io.IOException e) {
2406 jjStopStringLiteralDfa_2(3, active0, active1);
2407 return 4;
2408 }
2409 switch(curChar)
2410 {
2411 case 'g':
2412 return jjMoveStringLiteralDfa5_2(active0, 0x0L, active1, 0x1000000L);
2413 case 't':
2414 return jjMoveStringLiteralDfa5_2(active0, 0x100000000L, active1, 0x0L);
2415 default :
2416 break;
2417 }
2418 return jjStartNfa_2(3, active0, active1);
2419 }
2420 private int jjMoveStringLiteralDfa5_2(long old0, long active0, long old1, long active1){
2421 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2422 return jjStartNfa_2(3, old0, old1);
2423 try { curChar = input_stream.readChar(); }
2424 catch(java.io.IOException e) {
2425 jjStopStringLiteralDfa_2(4, active0, active1);
2426 return 5;
2427 }
2428 switch(curChar)
2429 {
2430 case 'a':
2431 return jjMoveStringLiteralDfa6_2(active0, 0x100000000L, active1, 0x0L);
2432 case 'm':
2433 return jjMoveStringLiteralDfa6_2(active0, 0x0L, active1, 0x1000000L);
2434 default :
2435 break;
2436 }
2437 return jjStartNfa_2(4, active0, active1);
2438 }
2439 private int jjMoveStringLiteralDfa6_2(long old0, long active0, long old1, long active1){
2440 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2441 return jjStartNfa_2(4, old0, old1);
2442 try { curChar = input_stream.readChar(); }
2443 catch(java.io.IOException e) {
2444 jjStopStringLiteralDfa_2(5, active0, active1);
2445 return 6;
2446 }
2447 switch(curChar)
2448 {
2449 case 'a':
2450 if ((active1 & 0x1000000L) != 0x0L)
2451 return jjStopAtPos(6, 88);
2452 break;
2453 case 'n':
2454 return jjMoveStringLiteralDfa7_2(active0, 0x100000000L, active1, 0x0L);
2455 default :
2456 break;
2457 }
2458 return jjStartNfa_2(5, active0, active1);
2459 }
2460 private int jjMoveStringLiteralDfa7_2(long old0, long active0, long old1, long active1){
2461 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2462 return jjStartNfa_2(5, old0, old1);
2463 try { curChar = input_stream.readChar(); }
2464 catch(java.io.IOException e) {
2465 jjStopStringLiteralDfa_2(6, active0, 0L);
2466 return 7;
2467 }
2468 switch(curChar)
2469 {
2470 case 'c':
2471 return jjMoveStringLiteralDfa8_2(active0, 0x100000000L);
2472 default :
2473 break;
2474 }
2475 return jjStartNfa_2(6, active0, 0L);
2476 }
2477 private int jjMoveStringLiteralDfa8_2(long old0, long active0){
2478 if (((active0 &= old0)) == 0L)
2479 return jjStartNfa_2(6, old0, 0L);
2480 try { curChar = input_stream.readChar(); }
2481 catch(java.io.IOException e) {
2482 jjStopStringLiteralDfa_2(7, active0, 0L);
2483 return 8;
2484 }
2485 switch(curChar)
2486 {
2487 case 'e':
2488 return jjMoveStringLiteralDfa9_2(active0, 0x100000000L);
2489 default :
2490 break;
2491 }
2492 return jjStartNfa_2(7, active0, 0L);
2493 }
2494 private int jjMoveStringLiteralDfa9_2(long old0, long active0){
2495 if (((active0 &= old0)) == 0L)
2496 return jjStartNfa_2(7, old0, 0L);
2497 try { curChar = input_stream.readChar(); }
2498 catch(java.io.IOException e) {
2499 jjStopStringLiteralDfa_2(8, active0, 0L);
2500 return 9;
2501 }
2502 switch(curChar)
2503 {
2504 case 'o':
2505 return jjMoveStringLiteralDfa10_2(active0, 0x100000000L);
2506 default :
2507 break;
2508 }
2509 return jjStartNfa_2(8, active0, 0L);
2510 }
2511 private int jjMoveStringLiteralDfa10_2(long old0, long active0){
2512 if (((active0 &= old0)) == 0L)
2513 return jjStartNfa_2(8, old0, 0L);
2514 try { curChar = input_stream.readChar(); }
2515 catch(java.io.IOException e) {
2516 jjStopStringLiteralDfa_2(9, active0, 0L);
2517 return 10;
2518 }
2519 switch(curChar)
2520 {
2521 case 'f':
2522 if ((active0 & 0x100000000L) != 0x0L)
2523 return jjStopAtPos(10, 32);
2524 break;
2525 default :
2526 break;
2527 }
2528 return jjStartNfa_2(9, active0, 0L);
2529 }
2530 private int jjStartNfaWithStates_2(int pos, int kind, int state)
2531 {
2532 jjmatchedKind = kind;
2533 jjmatchedPos = pos;
2534 try { curChar = input_stream.readChar(); }
2535 catch(java.io.IOException e) { return pos + 1; }
2536 return jjMoveNfa_2(state, pos + 1);
2537 }
2538 private int jjMoveNfa_2(int startState, int curPos)
2539 {
2540 int startsAt = 0;
2541 jjnewStateCnt = 39;
2542 int i = 1;
2543 jjstateSet[0] = startState;
2544 int kind = 0x7fffffff;
2545 for (;;)
2546 {
2547 if (++jjround == 0x7fffffff)
2548 ReInitRounds();
2549 if (curChar < 64)
2550 {
2551 long l = 1L << curChar;
2552 do
2553 {
2554 switch(jjstateSet[--i])
2555 {
2556 case 5:
2557 if ((0x3ff001000000000L & l) != 0x0L)
2558 {
2559 if (kind > 113)
2560 kind = 113;
2561 { jjCheckNAdd(6); }
2562 }
2563 else if (curChar == 47)
2564 { jjAddStates(73, 74); }
2565 else if (curChar == 39)
2566 { jjCheckNAddStates(75, 77); }
2567 else if (curChar == 34)
2568 { jjCheckNAddStates(78, 80); }
2569 else if (curChar == 35)
2570 jjstateSet[jjnewStateCnt++] = 0;
2571 break;
2572 case 28:
2573 if (curChar == 47)
2574 {
2575 if (kind > 8)
2576 kind = 8;
2577 { jjCheckNAddStates(81, 83); }
2578 }
2579 else if (curChar == 42)
2580 { jjCheckNAddTwoStates(29, 30); }
2581 break;
2582 case 0:
2583 if (curChar != 35)
2584 break;
2585 if (kind > 6)
2586 kind = 6;
2587 { jjCheckNAddStates(61, 63); }
2588 break;
2589 case 1:
2590 if ((0xffffffffffffdbffL & l) == 0x0L)
2591 break;
2592 if (kind > 6)
2593 kind = 6;
2594 { jjCheckNAddStates(61, 63); }
2595 break;
2596 case 2:
2597 if ((0x2400L & l) != 0x0L && kind > 6)
2598 kind = 6;
2599 break;
2600 case 3:
2601 if (curChar == 10 && kind > 6)
2602 kind = 6;
2603 break;
2604 case 4:
2605 if (curChar == 13)
2606 jjstateSet[jjnewStateCnt++] = 3;
2607 break;
2608 case 6:
2609 if ((0x3ff001000000000L & l) == 0x0L)
2610 break;
2611 if (kind > 113)
2612 kind = 113;
2613 { jjCheckNAdd(6); }
2614 break;
2615 case 7:
2616 if (curChar == 34)
2617 { jjCheckNAddStates(78, 80); }
2618 break;
2619 case 8:
2620 if ((0xfffffffbffffdbffL & l) != 0x0L)
2621 { jjCheckNAddStates(78, 80); }
2622 break;
2623 case 10:
2624 if ((0xffffffffffffdbffL & l) != 0x0L)
2625 { jjCheckNAddStates(78, 80); }
2626 break;
2627 case 11:
2628 if (curChar == 34 && kind > 128)
2629 kind = 128;
2630 break;
2631 case 12:
2632 if (curChar == 39)
2633 { jjCheckNAddStates(75, 77); }
2634 break;
2635 case 13:
2636 if ((0xffffff7fffffdbffL & l) != 0x0L)
2637 { jjCheckNAddStates(75, 77); }
2638 break;
2639 case 15:
2640 if ((0xffffffffffffdbffL & l) != 0x0L)
2641 { jjCheckNAddStates(75, 77); }
2642 break;
2643 case 16:
2644 if (curChar == 39 && kind > 128)
2645 kind = 128;
2646 break;
2647 case 18:
2648 { jjCheckNAddStates(13, 15); }
2649 break;
2650 case 20:
2651 if ((0xfffffffffffffffeL & l) != 0x0L)
2652 { jjCheckNAddStates(13, 15); }
2653 break;
2654 case 23:
2655 if (curChar == 47)
2656 { jjCheckNAddStates(84, 86); }
2657 break;
2658 case 24:
2659 if ((0xffff7fffffffc8ffL & l) != 0x0L)
2660 { jjCheckNAddStates(84, 86); }
2661 break;
2662 case 26:
2663 if (curChar == 47 && kind > 130)
2664 kind = 130;
2665 break;
2666 case 27:
2667 if (curChar == 47)
2668 { jjAddStates(73, 74); }
2669 break;
2670 case 29:
2671 if ((0xfffffbffffffffffL & l) != 0x0L)
2672 { jjCheckNAddTwoStates(29, 30); }
2673 break;
2674 case 30:
2675 if (curChar == 42)
2676 { jjCheckNAddStates(87, 89); }
2677 break;
2678 case 31:
2679 if ((0xffff7bffffffffffL & l) != 0x0L)
2680 { jjCheckNAddTwoStates(32, 30); }
2681 break;
2682 case 32:
2683 if ((0xfffffbffffffffffL & l) != 0x0L)
2684 { jjCheckNAddTwoStates(32, 30); }
2685 break;
2686 case 33:
2687 if (curChar == 47 && kind > 7)
2688 kind = 7;
2689 break;
2690 case 34:
2691 if (curChar != 47)
2692 break;
2693 if (kind > 8)
2694 kind = 8;
2695 { jjCheckNAddStates(81, 83); }
2696 break;
2697 case 35:
2698 if ((0xffffffffffffdbffL & l) == 0x0L)
2699 break;
2700 if (kind > 8)
2701 kind = 8;
2702 { jjCheckNAddStates(81, 83); }
2703 break;
2704 case 36:
2705 if ((0x2400L & l) != 0x0L && kind > 8)
2706 kind = 8;
2707 break;
2708 case 37:
2709 if (curChar == 10 && kind > 8)
2710 kind = 8;
2711 break;
2712 case 38:
2713 if (curChar == 13)
2714 jjstateSet[jjnewStateCnt++] = 37;
2715 break;
2716 default : break;
2717 }
2718 } while(i != startsAt);
2719 }
2720 else if (curChar < 128)
2721 {
2722 long l = 1L << (curChar & 077);
2723 do
2724 {
2725 switch(jjstateSet[--i])
2726 {
2727 case 5:
2728 if ((0x7fffffe87ffffffL & l) != 0x0L)
2729 {
2730 if (kind > 113)
2731 kind = 113;
2732 { jjCheckNAdd(6); }
2733 }
2734 else if (curChar == 126)
2735 { jjCheckNAdd(23); }
2736 else if (curChar == 96)
2737 { jjCheckNAddStates(13, 15); }
2738 break;
2739 case 1:
2740 if (kind > 6)
2741 kind = 6;
2742 { jjAddStates(61, 63); }
2743 break;
2744 case 6:
2745 if ((0x7fffffe87ffffffL & l) == 0x0L)
2746 break;
2747 if (kind > 113)
2748 kind = 113;
2749 { jjCheckNAdd(6); }
2750 break;
2751 case 8:
2752 if ((0xffffffffefffffffL & l) != 0x0L)
2753 { jjCheckNAddStates(78, 80); }
2754 break;
2755 case 9:
2756 if (curChar == 92)
2757 jjstateSet[jjnewStateCnt++] = 10;
2758 break;
2759 case 10:
2760 { jjCheckNAddStates(78, 80); }
2761 break;
2762 case 13:
2763 if ((0xffffffffefffffffL & l) != 0x0L)
2764 { jjCheckNAddStates(75, 77); }
2765 break;
2766 case 14:
2767 if (curChar == 92)
2768 jjstateSet[jjnewStateCnt++] = 15;
2769 break;
2770 case 15:
2771 { jjCheckNAddStates(75, 77); }
2772 break;
2773 case 17:
2774 if (curChar == 96)
2775 { jjCheckNAddStates(13, 15); }
2776 break;
2777 case 18:
2778 if ((0xfffffffeefffffffL & l) != 0x0L)
2779 { jjCheckNAddStates(13, 15); }
2780 break;
2781 case 19:
2782 if (curChar == 92)
2783 jjstateSet[jjnewStateCnt++] = 20;
2784 break;
2785 case 20:
2786 { jjCheckNAddStates(13, 15); }
2787 break;
2788 case 21:
2789 if (curChar == 96 && kind > 129)
2790 kind = 129;
2791 break;
2792 case 22:
2793 if (curChar == 126)
2794 { jjCheckNAdd(23); }
2795 break;
2796 case 24:
2797 { jjAddStates(84, 86); }
2798 break;
2799 case 25:
2800 if (curChar == 92)
2801 { jjCheckNAdd(23); }
2802 break;
2803 case 29:
2804 { jjCheckNAddTwoStates(29, 30); }
2805 break;
2806 case 31:
2807 case 32:
2808 { jjCheckNAddTwoStates(32, 30); }
2809 break;
2810 case 35:
2811 if (kind > 8)
2812 kind = 8;
2813 { jjAddStates(81, 83); }
2814 break;
2815 default : break;
2816 }
2817 } while(i != startsAt);
2818 }
2819 else
2820 {
2821 int hiByte = (curChar >> 8);
2822 int i1 = hiByte >> 6;
2823 long l1 = 1L << (hiByte & 077);
2824 int i2 = (curChar & 0xff) >> 6;
2825 long l2 = 1L << (curChar & 077);
2826 do
2827 {
2828 switch(jjstateSet[--i])
2829 {
2830 case 1:
2831 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
2832 break;
2833 if (kind > 6)
2834 kind = 6;
2835 { jjAddStates(61, 63); }
2836 break;
2837 case 8:
2838 case 10:
2839 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2840 { jjCheckNAddStates(78, 80); }
2841 break;
2842 case 13:
2843 case 15:
2844 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2845 { jjCheckNAddStates(75, 77); }
2846 break;
2847 case 18:
2848 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2849 { jjCheckNAddStates(13, 15); }
2850 break;
2851 case 20:
2852 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2853 { jjCheckNAddStates(13, 15); }
2854 break;
2855 case 24:
2856 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2857 { jjAddStates(84, 86); }
2858 break;
2859 case 29:
2860 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2861 { jjCheckNAddTwoStates(29, 30); }
2862 break;
2863 case 31:
2864 case 32:
2865 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2866 { jjCheckNAddTwoStates(32, 30); }
2867 break;
2868 case 35:
2869 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
2870 break;
2871 if (kind > 8)
2872 kind = 8;
2873 { jjAddStates(81, 83); }
2874 break;
2875 default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break;
2876 }
2877 } while(i != startsAt);
2878 }
2879 if (kind != 0x7fffffff)
2880 {
2881 jjmatchedKind = kind;
2882 jjmatchedPos = curPos;
2883 kind = 0x7fffffff;
2884 }
2885 ++curPos;
2886 i = jjnewStateCnt;
2887 jjnewStateCnt = startsAt;
2888 startsAt = 39 - jjnewStateCnt;
2889 if (i == startsAt)
2890 return curPos;
2891 try { curChar = input_stream.readChar(); }
2892 catch(final java.io.IOException e) { return curPos; }
2893 }
2894 }
2895
2896
2897 public static final String[] jjstrLiteralImages = {
2898 "", null, null, null, null, null, null, null, null, "\164\150\162\157\167",
2899 "\164\162\171", "\143\141\164\143\150", "\146\151\156\141\154\154\171",
2900 "\151\156\163\164\141\156\143\145\157\146", "\50", "\51", "\173", "\175", "\133", "\77\133", "\135", "\73", "\72", "\54",
2901 "\56", "\77\56", "\56\56\56", "\77", "\77\72", "\77\77", "\46\46", "\174\174",
2902 "\41\151\156\163\164\141\156\143\145\157\146", "\141\156\144", "\157\162", "\75\75", "\41\75", "\76", "\76\75", "\74",
2903 "\74\75", "\75\176", "\41\176", "\75\136", "\75\44", "\41\136", "\41\44", "\75\75\75",
2904 "\41\75\75", "\145\161", "\156\145", "\147\164", "\147\145", "\154\164", "\154\145",
2905 "\53\75", "\55\75", "\52\75", "\57\75", "\45\75", "\46\75", "\174\75", "\136\75",
2906 "\74\74\75", "\76\76\76\75", "\76\76\75", "\75", "\53", "\53\53", "\55", "\55\55", "\52",
2907 "\57", "\45", "\41", "\46", "\174", "\136", "\74\74", "\76\76\76", "\76\76", "\176",
2908 "\56\56", "\156\157\164", "\144\151\166", "\155\157\144", "\55\76", "\75\76",
2909 "\43\160\162\141\147\155\141", "\151\146", "\145\154\163\145", "\144\157", "\167\150\151\154\145",
2910 "\146\157\162", "\142\162\145\141\153", "\143\157\156\164\151\156\165\145",
2911 "\146\165\156\143\164\151\157\156", "\162\145\164\165\162\156", "\156\145\167", "\163\151\172\145",
2912 "\145\155\160\164\171", "\166\141\162", "\154\145\164", "\143\157\156\163\164", "\156\165\154\154",
2913 "\164\162\165\145", "\146\141\154\163\145", "\163\167\151\164\143\150", "\143\141\163\145",
2914 "\144\145\146\141\165\154\164", "\151\155\160\157\162\164", "\116\141\116", null, null, null, null, null, null,
2915 null, null, null, null, null, null, null, null, null, null, null, null, null, };
2916 protected Token jjFillToken()
2917 {
2918 final Token t;
2919 final String curTokenImage;
2920 final int beginLine;
2921 final int endLine;
2922 final int beginColumn;
2923 final int endColumn;
2924 String im = jjstrLiteralImages[jjmatchedKind];
2925 curTokenImage = im == null ? input_stream.getImage() : im;
2926 beginLine = input_stream.getBeginLine();
2927 beginColumn = input_stream.getBeginColumn();
2928 endLine = input_stream.getEndLine();
2929 endColumn = input_stream.getEndColumn();
2930 t = Token.newToken(jjmatchedKind);
2931 t.kind = jjmatchedKind;
2932 t.image = curTokenImage;
2933
2934 t.beginLine = beginLine;
2935 t.endLine = endLine;
2936 t.beginColumn = beginColumn;
2937 t.endColumn = endColumn;
2938
2939 return t;
2940 }
2941 static final int[] jjnextStates = {
2942 38, 39, 44, 45, 46, 16, 63, 69, 54, 61, 23, 24, 26, 18, 19, 21,
2943 50, 52, 10, 70, 71, 73, 55, 56, 58, 12, 13, 16, 28, 29, 31, 34,
2944 35, 36, 40, 41, 16, 44, 45, 46, 16, 65, 66, 68, 14, 15, 42, 43,
2945 47, 48, 34, 35, 37, 27, 33, 12, 13, 15, 7, 8, 10, 1, 2, 4,
2946 17, 18, 20, 23, 24, 25, 29, 30, 32, 28, 34, 13, 14, 16, 8, 9,
2947 11, 35, 36, 38, 24, 25, 26, 30, 31, 33,
2948 };
2949 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
2950 {
2951 switch(hiByte)
2952 {
2953 case 0:
2954 return ((jjbitVec2[i2] & l2) != 0L);
2955 case 32:
2956 return ((jjbitVec3[i2] & l2) != 0L);
2957 default :
2958 if ((jjbitVec0[i1] & l1) != 0L)
2959 return true;
2960 return false;
2961 }
2962 }
2963 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
2964 {
2965 switch(hiByte)
2966 {
2967 case 0:
2968 return ((jjbitVec2[i2] & l2) != 0L);
2969 case 32:
2970 return ((jjbitVec4[i2] & l2) != 0L);
2971 default :
2972 if ((jjbitVec0[i1] & l1) != 0L)
2973 return true;
2974 return false;
2975 }
2976 }
2977 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
2978 {
2979 switch(hiByte)
2980 {
2981 case 0:
2982 return ((jjbitVec2[i2] & l2) != 0L);
2983 default :
2984 if ((jjbitVec5[i1] & l1) != 0L)
2985 return true;
2986 return false;
2987 }
2988 }
2989
2990 int curLexState = 0;
2991 int defaultLexState = 0;
2992 int jjnewStateCnt;
2993 int jjround;
2994 int jjmatchedPos;
2995 int jjmatchedKind;
2996
2997
2998 public Token getNextToken()
2999 {
3000 Token matchedToken;
3001 int curPos = 0;
3002
3003 EOFLoop:
3004 for (;;)
3005 {
3006 try
3007 {
3008 curChar = input_stream.beginToken();
3009 }
3010 catch(final Exception e)
3011 {
3012 jjmatchedKind = 0;
3013 jjmatchedPos = -1;
3014 matchedToken = jjFillToken();
3015 return matchedToken;
3016 }
3017 image = jjimage;
3018 image.setLength(0);
3019 jjimageLen = 0;
3020
3021 switch(curLexState)
3022 {
3023 case 0:
3024 try {
3025 input_stream.backup(0);
3026 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0x0L)
3027 curChar = input_stream.beginToken();
3028 }
3029 catch (final java.io.IOException e1) {
3030 continue EOFLoop;
3031 }
3032 jjmatchedKind = 0x7fffffff;
3033 jjmatchedPos = 0;
3034 curPos = jjMoveStringLiteralDfa0_0();
3035 break;
3036 case 1:
3037 try {
3038 input_stream.backup(0);
3039 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0x0L)
3040 curChar = input_stream.beginToken();
3041 }
3042 catch (final java.io.IOException e1) {
3043 continue EOFLoop;
3044 }
3045 jjmatchedKind = 0x7fffffff;
3046 jjmatchedPos = 0;
3047 curPos = jjMoveStringLiteralDfa0_1();
3048 break;
3049 case 2:
3050 try {
3051 input_stream.backup(0);
3052 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0x0L)
3053 curChar = input_stream.beginToken();
3054 }
3055 catch (final java.io.IOException e1) {
3056 continue EOFLoop;
3057 }
3058 jjmatchedKind = 0x7fffffff;
3059 jjmatchedPos = 0;
3060 curPos = jjMoveStringLiteralDfa0_2();
3061 break;
3062 }
3063 if (jjmatchedKind != 0x7fffffff)
3064 {
3065 if (jjmatchedPos + 1 < curPos)
3066 input_stream.backup(curPos - jjmatchedPos - 1);
3067 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3068 {
3069 matchedToken = jjFillToken();
3070 TokenLexicalActions(matchedToken);
3071 if (jjnewLexState[jjmatchedKind] != -1)
3072 curLexState = jjnewLexState[jjmatchedKind];
3073 return matchedToken;
3074 }
3075 else
3076 {
3077 if (jjnewLexState[jjmatchedKind] != -1)
3078 curLexState = jjnewLexState[jjmatchedKind];
3079 continue EOFLoop;
3080 }
3081 }
3082 int error_line = input_stream.getEndLine();
3083 int error_column = input_stream.getEndColumn();
3084 String error_after = null;
3085 boolean EOFSeen = false;
3086 try {
3087 input_stream.readChar();
3088 input_stream.backup(1);
3089 }
3090 catch (final java.io.IOException e1) {
3091 EOFSeen = true;
3092 error_after = curPos <= 1 ? "" : input_stream.getImage();
3093 if (curChar == '\n' || curChar == '\r') {
3094 error_line++;
3095 error_column = 0;
3096 }
3097 else
3098 error_column++;
3099 }
3100 if (!EOFSeen) {
3101 input_stream.backup(1);
3102 error_after = curPos <= 1 ? "" : input_stream.getImage();
3103 }
3104 throw new TokenMgrException(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrException.LEXICAL_ERROR);
3105 }
3106 }
3107
3108 void SkipLexicalActions(Token matchedToken)
3109 {
3110 switch(jjmatchedKind)
3111 {
3112 default :
3113 break;
3114 }
3115 }
3116 void MoreLexicalActions()
3117 {
3118 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
3119 switch(jjmatchedKind)
3120 {
3121 default :
3122 break;
3123 }
3124 }
3125 void TokenLexicalActions(Token matchedToken)
3126 {
3127 switch(jjmatchedKind)
3128 {
3129 case 114 :
3130 image.append(input_stream.getSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3131 matchedToken.image = StringParser.unescapeIdentifier(matchedToken.image);
3132 final int length = matchedToken.image.length();
3133 if (comparatorNames && length == 2) {
3134 switch (matchedToken.image) {
3135 case "ne" : matchedToken.kind = NE; break;
3136 case "eq" : matchedToken.kind = EQ; break;
3137 case "lt" : matchedToken.kind = LT; break;
3138 case "le" : matchedToken.kind = LE; break;
3139 case "gt" : matchedToken.kind = GT; break;
3140 case "ge" : matchedToken.kind = GE; break;
3141 }
3142 } else if (jexl331 && length >= 3 && length <= 10) {
3143 switch (matchedToken.image) {
3144 case "try" : matchedToken.kind = TRY; break;
3145 case "catch" : matchedToken.kind = CATCH; break;
3146 case "finally" : matchedToken.kind = FINALLY; break;
3147 case "throw" : matchedToken.kind = THROW; break;
3148 case "instanceof": matchedToken.kind = ISA; break;
3149 case "!instanceof": matchedToken.kind = NISA; break;
3150 }
3151 }
3152 break;
3153 default :
3154 break;
3155 }
3156 }
3157 private void jjCheckNAdd(int state)
3158 {
3159 if (jjrounds[state] != jjround)
3160 {
3161 jjstateSet[jjnewStateCnt++] = state;
3162 jjrounds[state] = jjround;
3163 }
3164 }
3165 private void jjAddStates(int start, int end)
3166 {
3167 do {
3168 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
3169 } while (start++ != end);
3170 }
3171 private void jjCheckNAddTwoStates(int state1, int state2)
3172 {
3173 jjCheckNAdd(state1);
3174 jjCheckNAdd(state2);
3175 }
3176
3177 private void jjCheckNAddStates(int start, int end)
3178 {
3179 do {
3180 jjCheckNAdd(jjnextStates[start]);
3181 } while (start++ != end);
3182 }
3183
3184
3185 public ParserTokenManager(SimpleCharStream stream){
3186 input_stream = stream;
3187 }
3188
3189
3190 public ParserTokenManager (SimpleCharStream stream, int lexState){
3191 ReInit(stream);
3192 SwitchTo(lexState);
3193 }
3194
3195
3196
3197 public void ReInit(SimpleCharStream stream)
3198 {
3199
3200
3201 jjmatchedPos =
3202 jjnewStateCnt =
3203 0;
3204 curLexState = defaultLexState;
3205 input_stream = stream;
3206 ReInitRounds();
3207 }
3208
3209 private void ReInitRounds()
3210 {
3211 int i;
3212 jjround = 0x80000001;
3213 for (i = 74; i-- > 0;)
3214 jjrounds[i] = 0x80000000;
3215 }
3216
3217
3218 public void ReInit(SimpleCharStream stream, int lexState)
3219 {
3220 ReInit(stream);
3221 SwitchTo(lexState);
3222 }
3223
3224
3225 public void SwitchTo(int lexState)
3226 {
3227 if (lexState >= 3 || lexState < 0)
3228 throw new TokenMgrException("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrException.INVALID_LEXICAL_STATE);
3229 else
3230 curLexState = lexState;
3231 }
3232
3233
3234
3235 public static final String[] lexStateNames = {
3236 "DEFAULT",
3237 "NEVER",
3238 "DOT_ID",
3239 };
3240
3241
3242 public static final int[] jjnewLexState = {
3243 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2,
3244 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3245 -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,
3246 -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,
3247 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3248 -1, -1, -1, 0, 0, -1,
3249 };
3250 static final long[] jjtoToken = {
3251 0xfffffffffffffe01L, 0x10c7ffffffffffffL, 0x7L,
3252 };
3253 static final long[] jjtoSkip = {
3254 0x1feL, 0x0L, 0x0L,
3255 };
3256 static final long[] jjtoSpecial = {
3257 0x0L, 0x0L, 0x0L,
3258 };
3259 static final long[] jjtoMore = {
3260 0x0L, 0x0L, 0x0L,
3261 };
3262 protected SimpleCharStream input_stream;
3263
3264 private final int[] jjrounds = new int[74];
3265 private final int[] jjstateSet = new int[2 * 74];
3266 private final StringBuilder jjimage = new StringBuilder();
3267 private StringBuilder image = jjimage;
3268 private int jjimageLen;
3269 private int lengthOfMatch;
3270 protected int curChar;
3271 }