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