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