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