|
1
2
9 package org.codehaus.aspectwerkz.expression.ast;
10 import java.lang.reflect.Modifier  ;
11 import java.io.Reader ;
12 import java.io.StringReader ;
13
14 public class ExpressionParserTokenManager implements ExpressionParserConstants
15 {
16 public static java.io.PrintStream debugStream = System.out;
17 public static void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
18 private static final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
19 {
20 switch (pos)
21 {
22 case 0:
23 if ((active0 & 0x7dff800L) != 0L)
24 {
25 jjmatchedKind = 28;
26 return 22;
27 }
28 if ((active0 & 0x10L) != 0L)
29 return 1;
30 if ((active0 & 0x200000L) != 0L)
31 {
32 jjmatchedKind = 28;
33 return 5;
34 }
35 return -1;
36 case 1:
37 if ((active0 & 0x7fff800L) != 0L)
38 {
39 jjmatchedKind = 28;
40 jjmatchedPos = 1;
41 return 22;
42 }
43 return -1;
44 case 2:
45 if ((active0 & 0x6fff800L) != 0L)
46 {
47 jjmatchedKind = 28;
48 jjmatchedPos = 2;
49 return 22;
50 }
51 return -1;
52 case 3:
53 if ((active0 & 0x6ff9800L) != 0L)
54 {
55 jjmatchedKind = 28;
56 jjmatchedPos = 3;
57 return 22;
58 }
59 return -1;
60 case 4:
61 if ((active0 & 0x65f8800L) != 0L)
62 {
63 jjmatchedKind = 28;
64 jjmatchedPos = 4;
65 return 22;
66 }
67 return -1;
68 case 5:
69 if ((active0 & 0x6578800L) != 0L)
70 {
71 jjmatchedKind = 28;
72 jjmatchedPos = 5;
73 return 22;
74 }
75 return -1;
76 case 6:
77 if ((active0 & 0x6168800L) != 0L)
78 {
79 jjmatchedKind = 28;
80 jjmatchedPos = 6;
81 return 22;
82 }
83 return -1;
84 case 7:
85 if ((active0 & 0x6160800L) != 0L)
86 {
87 jjmatchedKind = 28;
88 jjmatchedPos = 7;
89 return 22;
90 }
91 return -1;
92 case 8:
93 if ((active0 & 0x2160800L) != 0L)
94 {
95 jjmatchedKind = 28;
96 jjmatchedPos = 8;
97 return 22;
98 }
99 return -1;
100 case 9:
101 if ((active0 & 0x160000L) != 0L)
102 {
103 jjmatchedKind = 28;
104 jjmatchedPos = 9;
105 return 22;
106 }
107 return -1;
108 case 10:
109 if ((active0 & 0x40000L) != 0L)
110 {
111 jjmatchedKind = 28;
112 jjmatchedPos = 10;
113 return 22;
114 }
115 return -1;
116 case 11:
117 if ((active0 & 0x40000L) != 0L)
118 {
119 jjmatchedKind = 28;
120 jjmatchedPos = 11;
121 return 22;
122 }
123 return -1;
124 case 12:
125 if ((active0 & 0x40000L) != 0L)
126 {
127 jjmatchedKind = 28;
128 jjmatchedPos = 12;
129 return 22;
130 }
131 return -1;
132 case 13:
133 if ((active0 & 0x40000L) != 0L)
134 {
135 jjmatchedKind = 28;
136 jjmatchedPos = 13;
137 return 22;
138 }
139 return -1;
140 case 14:
141 if ((active0 & 0x40000L) != 0L)
142 {
143 jjmatchedKind = 28;
144 jjmatchedPos = 14;
145 return 22;
146 }
147 return -1;
148 case 15:
149 if ((active0 & 0x40000L) != 0L)
150 {
151 jjmatchedKind = 28;
152 jjmatchedPos = 15;
153 return 22;
154 }
155 return -1;
156 case 16:
157 if ((active0 & 0x40000L) != 0L)
158 {
159 jjmatchedKind = 28;
160 jjmatchedPos = 16;
161 return 22;
162 }
163 return -1;
164 case 17:
165 if ((active0 & 0x40000L) != 0L)
166 {
167 jjmatchedKind = 28;
168 jjmatchedPos = 17;
169 return 22;
170 }
171 return -1;
172 case 18:
173 if ((active0 & 0x40000L) != 0L)
174 {
175 jjmatchedKind = 28;
176 jjmatchedPos = 18;
177 return 22;
178 }
179 return -1;
180 case 19:
181 if ((active0 & 0x40000L) != 0L)
182 {
183 jjmatchedKind = 28;
184 jjmatchedPos = 19;
185 return 22;
186 }
187 return -1;
188 default :
189 return -1;
190 }
191 }
192 private static final int jjStartNfa_5(int pos, long active0, long active1)
193 {
194 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
195 }
196 static private final int jjStopAtPos(int pos, int kind)
197 {
198 jjmatchedKind = kind;
199 jjmatchedPos = pos;
200 return pos + 1;
201 }
202 static private final int jjStartNfaWithStates_5(int pos, int kind, int state)
203 {
204 jjmatchedKind = kind;
205 jjmatchedPos = pos;
206 try { curChar = input_stream.readChar(); }
207 catch(java.io.IOException e) { return pos + 1; }
208 return jjMoveNfa_5(state, pos + 1);
209 }
210 static private final int jjMoveStringLiteralDfa0_5()
211 {
212 switch(curChar)
213 {
214 case 33:
215 return jjStopAtPos(0, 10);
216 case 40:
217 return jjStopAtPos(0, 86);
218 case 41:
219 return jjStopAtPos(0, 87);
220 case 44:
221 return jjStopAtPos(0, 3);
222 case 46:
223 return jjStartNfaWithStates_5(0, 4, 1);
224 case 97:
225 return jjMoveStringLiteralDfa1_5(0x200000L);
226 case 99:
227 return jjMoveStringLiteralDfa1_5(0x181000L);
228 case 101:
229 return jjMoveStringLiteralDfa1_5(0x800L);
230 case 103:
231 return jjMoveStringLiteralDfa1_5(0x4000L);
232 case 104:
233 return jjMoveStringLiteralDfa1_5(0x6008000L);
234 case 105:
235 return jjMoveStringLiteralDfa1_5(0x1000000L);
236 case 115:
237 return jjMoveStringLiteralDfa1_5(0x42000L);
238 case 116:
239 return jjMoveStringLiteralDfa1_5(0xc00000L);
240 case 119:
241 return jjMoveStringLiteralDfa1_5(0x30000L);
242 default :
243 return jjMoveNfa_5(0, 0);
244 }
245 }
246 static private final int jjMoveStringLiteralDfa1_5(long active0)
247 {
248 try { curChar = input_stream.readChar(); }
249 catch(java.io.IOException e) {
250 jjStopStringLiteralDfa_5(0, active0, 0L);
251 return 1;
252 }
253 switch(curChar)
254 {
255 case 97:
256 return jjMoveStringLiteralDfa2_5(active0, 0x6409000L);
257 case 101:
258 return jjMoveStringLiteralDfa2_5(active0, 0x6000L);
259 case 102:
260 return jjMoveStringLiteralDfa2_5(active0, 0x1180000L);
261 case 104:
262 return jjMoveStringLiteralDfa2_5(active0, 0x800000L);
263 case 105:
264 return jjMoveStringLiteralDfa2_5(active0, 0x30000L);
265 case 114:
266 return jjMoveStringLiteralDfa2_5(active0, 0x200000L);
267 case 116:
268 return jjMoveStringLiteralDfa2_5(active0, 0x40000L);
269 case 120:
270 return jjMoveStringLiteralDfa2_5(active0, 0x800L);
271 default :
272 break;
273 }
274 return jjStartNfa_5(0, active0, 0L);
275 }
276 static private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
277 {
278 if (((active0 &= old0)) == 0L)
279 return jjStartNfa_5(0, old0, 0L);
280 try { curChar = input_stream.readChar(); }
281 catch(java.io.IOException e) {
282 jjStopStringLiteralDfa_5(1, active0, 0L);
283 return 2;
284 }
285 switch(curChar)
286 {
287 case 40:
288 if ((active0 & 0x1000000L) != 0L)
289 return jjStopAtPos(2, 24);
290 break;
291 case 97:
292 return jjMoveStringLiteralDfa3_5(active0, 0x40000L);
293 case 101:
294 return jjMoveStringLiteralDfa3_5(active0, 0x800L);
295 case 103:
296 return jjMoveStringLiteralDfa3_5(active0, 0x200000L);
297 case 105:
298 return jjMoveStringLiteralDfa3_5(active0, 0x800000L);
299 case 108:
300 return jjMoveStringLiteralDfa3_5(active0, 0x181000L);
301 case 110:
302 return jjMoveStringLiteralDfa3_5(active0, 0x8000L);
303 case 114:
304 return jjMoveStringLiteralDfa3_5(active0, 0x400000L);
305 case 115:
306 return jjMoveStringLiteralDfa3_5(active0, 0x6000000L);
307 case 116:
308 return jjMoveStringLiteralDfa3_5(active0, 0x36000L);
309 default :
310 break;
311 }
312 return jjStartNfa_5(1, active0, 0L);
313 }
314 static private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
315 {
316 if (((active0 &= old0)) == 0L)
317 return jjStartNfa_5(1, old0, 0L);
318 try { curChar = input_stream.readChar(); }
319 catch(java.io.IOException e) {
320 jjStopStringLiteralDfa_5(2, active0, 0L);
321 return 3;
322 }
323 switch(curChar)
324 {
325 case 40:
326 if ((active0 & 0x2000L) != 0L)
327 return jjStopAtPos(3, 13);
328 else if ((active0 & 0x4000L) != 0L)
329 return jjStopAtPos(3, 14);
330 break;
331 case 99:
332 return jjMoveStringLiteralDfa4_5(active0, 0x800L);
333 case 100:
334 return jjMoveStringLiteralDfa4_5(active0, 0x8000L);
335 case 102:
336 return jjMoveStringLiteralDfa4_5(active0, 0x4000000L);
337 case 103:
338 return jjMoveStringLiteralDfa4_5(active0, 0x400000L);
339 case 104:
340 return jjMoveStringLiteralDfa4_5(active0, 0x30000L);
341 case 108:
342 return jjMoveStringLiteralDfa4_5(active0, 0x1000L);
343 case 109:
344 return jjMoveStringLiteralDfa4_5(active0, 0x2000000L);
345 case 111:
346 return jjMoveStringLiteralDfa4_5(active0, 0x180000L);
347 case 115:
348 return jjMoveStringLiteralDfa4_5(active0, 0xa00000L);
349 case 116:
350 return jjMoveStringLiteralDfa4_5(active0, 0x40000L);
351 default :
352 break;
353 }
354 return jjStartNfa_5(2, active0, 0L);
355 }
356 static private final int jjMoveStringLiteralDfa4_5(long old0, long active0)
357 {
358 if (((active0 &= old0)) == 0L)
359 return jjStartNfa_5(2, old0, 0L);
360 try { curChar = input_stream.readChar(); }
361 catch(java.io.IOException e) {
362 jjStopStringLiteralDfa_5(3, active0, 0L);
363 return 4;
364 }
365 switch(curChar)
366 {
367 case 40:
368 if ((active0 & 0x1000L) != 0L)
369 return jjStopAtPos(4, 12);
370 else if ((active0 & 0x200000L) != 0L)
371 return jjStopAtPos(4, 21);
372 else if ((active0 & 0x800000L) != 0L)
373 return jjStopAtPos(4, 23);
374 break;
375 case 101:
376 return jjMoveStringLiteralDfa5_5(active0, 0x2400000L);
377 case 105:
378 return jjMoveStringLiteralDfa5_5(active0, 0x4070000L);
379 case 108:
380 return jjMoveStringLiteralDfa5_5(active0, 0x8000L);
381 case 117:
382 return jjMoveStringLiteralDfa5_5(active0, 0x800L);
383 case 119:
384 return jjMoveStringLiteralDfa5_5(active0, 0x180000L);
385 default :
386 break;
387 }
388 return jjStartNfa_5(3, active0, 0L);
389 }
390 static private final int jjMoveStringLiteralDfa5_5(long old0, long active0)
391 {
392 if (((active0 &= old0)) == 0L)
393 return jjStartNfa_5(3, old0, 0L);
394 try { curChar = input_stream.readChar(); }
395 catch(java.io.IOException e) {
396 jjStopStringLiteralDfa_5(4, active0, 0L);
397 return 5;
398 }
399 switch(curChar)
400 {
401 case 40:
402 if ((active0 & 0x80000L) != 0L)
403 return jjStopAtPos(5, 19);
404 break;
405 case 98:
406 return jjMoveStringLiteralDfa6_5(active0, 0x100000L);
407 case 99:
408 return jjMoveStringLiteralDfa6_5(active0, 0x40000L);
409 case 101:
410 return jjMoveStringLiteralDfa6_5(active0, 0x4008000L);
411 case 110:
412 return jjMoveStringLiteralDfa6_5(active0, 0x30000L);
413 case 116:
414 return jjMoveStringLiteralDfa6_5(active0, 0x2400800L);
415 default :
416 break;
417 }
418 return jjStartNfa_5(4, active0, 0L);
419 }
420 static private final int jjMoveStringLiteralDfa6_5(long old0, long active0)
421 {
422 if (((active0 &= old0)) == 0L)
423 return jjStartNfa_5(4, old0, 0L);
424 try { curChar = input_stream.readChar(); }
425 catch(java.io.IOException e) {
426 jjStopStringLiteralDfa_5(5, active0, 0L);
427 return 6;
428 }
429 switch(curChar)
430 {
431 case 40:
432 if ((active0 & 0x10000L) != 0L)
433 return jjStopAtPos(6, 16);
434 else if ((active0 & 0x400000L) != 0L)
435 return jjStopAtPos(6, 22);
436 break;
437 case 99:
438 return jjMoveStringLiteralDfa7_5(active0, 0x20000L);
439 case 101:
440 return jjMoveStringLiteralDfa7_5(active0, 0x100000L);
441 case 104:
442 return jjMoveStringLiteralDfa7_5(active0, 0x2000000L);
443 case 105:
444 return jjMoveStringLiteralDfa7_5(active0, 0x40800L);
445 case 108:
446 return jjMoveStringLiteralDfa7_5(active0, 0x4000000L);
447 case 114:
448 return jjMoveStringLiteralDfa7_5(active0, 0x8000L);
449 default :
450 break;
451 }
452 return jjStartNfa_5(5, active0, 0L);
453 }
454 static private final int jjMoveStringLiteralDfa7_5(long old0, long active0)
455 {
456 if (((active0 &= old0)) == 0L)
457 return jjStartNfa_5(5, old0, 0L);
458 try { curChar = input_stream.readChar(); }
459 catch(java.io.IOException e) {
460 jjStopStringLiteralDfa_5(6, active0, 0L);
461 return 7;
462 }
463 switch(curChar)
464 {
465 case 40:
466 if ((active0 & 0x8000L) != 0L)
467 return jjStopAtPos(7, 15);
468 break;
469 case 100:
470 return jjMoveStringLiteralDfa8_5(active0, 0x4000000L);
471 case 108:
472 return jjMoveStringLiteralDfa8_5(active0, 0x100000L);
473 case 110:
474 return jjMoveStringLiteralDfa8_5(active0, 0x40000L);
475 case 111:
476 return jjMoveStringLiteralDfa8_5(active0, 0x2020800L);
477 default :
478 break;
479 }
480 return jjStartNfa_5(6, active0, 0L);
481 }
482 static private final int jjMoveStringLiteralDfa8_5(long old0, long active0)
483 {
484 if (((active0 &= old0)) == 0L)
485 return jjStartNfa_5(6, old0, 0L);
486 try { curChar = input_stream.readChar(); }
487 catch(java.io.IOException e) {
488 jjStopStringLiteralDfa_5(7, active0, 0L);
489 return 8;
490 }
491 switch(curChar)
492 {
493 case 40:
494 if ((active0 & 0x4000000L) != 0L)
495 return jjStopAtPos(8, 26);
496 break;
497 case 100:
498 return jjMoveStringLiteralDfa9_5(active0, 0x2020000L);
499 case 105:
500 return jjMoveStringLiteralDfa9_5(active0, 0x40000L);
501 case 110:
502 return jjMoveStringLiteralDfa9_5(active0, 0x800L);
503 case 111:
504 return jjMoveStringLiteralDfa9_5(active0, 0x100000L);
505 default :
506 break;
507 }
508 return jjStartNfa_5(7, active0, 0L);
509 }
510 static private final int jjMoveStringLiteralDfa9_5(long old0, long active0)
511 {
512 if (((active0 &= old0)) == 0L)
513 return jjStartNfa_5(7, old0, 0L);
514 try { curChar = input_stream.readChar(); }
515 catch(java.io.IOException e) {
516 jjStopStringLiteralDfa_5(8, active0, 0L);
517 return 9;
518 }
519 switch(curChar)
520 {
521 case 40:
522 if ((active0 & 0x800L) != 0L)
523 return jjStopAtPos(9, 11);
524 else if ((active0 & 0x2000000L) != 0L)
525 return jjStopAtPos(9, 25);
526 break;
527 case 101:
528 return jjMoveStringLiteralDfa10_5(active0, 0x20000L);
529 case 116:
530 return jjMoveStringLiteralDfa10_5(active0, 0x40000L);
531 case 119:
532 return jjMoveStringLiteralDfa10_5(active0, 0x100000L);
533 default :
534 break;
535 }
536 return jjStartNfa_5(8, active0, 0L);
537 }
538 static private final int jjMoveStringLiteralDfa10_5(long old0, long active0)
539 {
540 if (((active0 &= old0)) == 0L)
541 return jjStartNfa_5(8, old0, 0L);
542 try { curChar = input_stream.readChar(); }
543 catch(java.io.IOException e) {
544 jjStopStringLiteralDfa_5(9, active0, 0L);
545 return 10;
546 }
547 switch(curChar)
548 {
549 case 40:
550 if ((active0 & 0x20000L) != 0L)
551 return jjStopAtPos(10, 17);
552 else if ((active0 & 0x100000L) != 0L)
553 return jjStopAtPos(10, 20);
554 break;
555 case 105:
556 return jjMoveStringLiteralDfa11_5(active0, 0x40000L);
557 default :
558 break;
559 }
560 return jjStartNfa_5(9, active0, 0L);
561 }
562 static private final int jjMoveStringLiteralDfa11_5(long old0, long active0)
563 {
564 if (((active0 &= old0)) == 0L)
565 return jjStartNfa_5(9, old0, 0L);
566 try { curChar = input_stream.readChar(); }
567 catch(java.io.IOException e) {
568 jjStopStringLiteralDfa_5(10, active0, 0L);
569 return 11;
570 }
571 switch(curChar)
572 {
573 case 97:
574 return jjMoveStringLiteralDfa12_5(active0, 0x40000L);
575 default :
576 break;
577 }
578 return jjStartNfa_5(10, active0, 0L);
579 }
580 static private final int jjMoveStringLiteralDfa12_5(long old0, long active0)
581 {
582 if (((active0 &= old0)) == 0L)
583 return jjStartNfa_5(10, old0, 0L);
584 try { curChar = input_stream.readChar(); }
585 catch(java.io.IOException e) {
586 jjStopStringLiteralDfa_5(11, active0, 0L);
587 return 12;
588 }
589 switch(curChar)
590 {
591 case 108:
592 return jjMoveStringLiteralDfa13_5(active0, 0x40000L);
593 default :
594 break;
595 }
596 return jjStartNfa_5(11, active0, 0L);
597 }
598 static private final int jjMoveStringLiteralDfa13_5(long old0, long active0)
599 {
600 if (((active0 &= old0)) == 0L)
601 return jjStartNfa_5(11, old0, 0L);
602 try { curChar = input_stream.readChar(); }
603 catch(java.io.IOException e) {
604 jjStopStringLiteralDfa_5(12, active0, 0L);
605 return 13;
606 }
607 switch(curChar)
608 {
609 case 105:
610 return jjMoveStringLiteralDfa14_5(active0, 0x40000L);
611 default :
612 break;
613 }
614 return jjStartNfa_5(12, active0, 0L);
615 }
616 static private final int jjMoveStringLiteralDfa14_5(long old0, long active0)
617 {
618 if (((active0 &= old0)) == 0L)
619 return jjStartNfa_5(12, old0, 0L);
620 try { curChar = input_stream.readChar(); }
621 catch(java.io.IOException e) {
622 jjStopStringLiteralDfa_5(13, active0, 0L);
623 return 14;
624 }
625 switch(curChar)
626 {
627 case 122:
628 return jjMoveStringLiteralDfa15_5(active0, 0x40000L);
629 default :
630 break;
631 }
632 return jjStartNfa_5(13, active0, 0L);
633 }
634 static private final int jjMoveStringLiteralDfa15_5(long old0, long active0)
635 {
636 if (((active0 &= old0)) == 0L)
637 return jjStartNfa_5(13, old0, 0L);
638 try { curChar = input_stream.readChar(); }
639 catch(java.io.IOException e) {
640 jjStopStringLiteralDfa_5(14, active0, 0L);
641 return 15;
642 }
643 switch(curChar)
644 {
645 case 97:
646 return jjMoveStringLiteralDfa16_5(active0, 0x40000L);
647 default :
648 break;
649 }
650 return jjStartNfa_5(14, active0, 0L);
651 }
652 static private final int jjMoveStringLiteralDfa16_5(long old0, long active0)
653 {
654 if (((active0 &= old0)) == 0L)
655 return jjStartNfa_5(14, old0, 0L);
656 try { curChar = input_stream.readChar(); }
657 catch(java.io.IOException e) {
658 jjStopStringLiteralDfa_5(15, active0, 0L);
659 return 16;
660 }
661 switch(curChar)
662 {
663 case 116:
664 return jjMoveStringLiteralDfa17_5(active0, 0x40000L);
665 default :
666 break;
667 }
668 return jjStartNfa_5(15, active0, 0L);
669 }
670 static private final int jjMoveStringLiteralDfa17_5(long old0, long active0)
671 {
672 if (((active0 &= old0)) == 0L)
673 return jjStartNfa_5(15, old0, 0L);
674 try { curChar = input_stream.readChar(); }
675 catch(java.io.IOException e) {
676 jjStopStringLiteralDfa_5(16, active0, 0L);
677 return 17;
678 }
679 switch(curChar)
680 {
681 case 105:
682 return jjMoveStringLiteralDfa18_5(active0, 0x40000L);
683 default :
684 break;
685 }
686 return jjStartNfa_5(16, active0, 0L);
687 }
688 static private final int jjMoveStringLiteralDfa18_5(long old0, long active0)
689 {
690 if (((active0 &= old0)) == 0L)
691 return jjStartNfa_5(16, old0, 0L);
692 try { curChar = input_stream.readChar(); }
693 catch(java.io.IOException e) {
694 jjStopStringLiteralDfa_5(17, active0, 0L);
695 return 18;
696 }
697 switch(curChar)
698 {
699 case 111:
700 return jjMoveStringLiteralDfa19_5(active0, 0x40000L);
701 default :
702 break;
703 }
704 return jjStartNfa_5(17, active0, 0L);
705 }
706 static private final int jjMoveStringLiteralDfa19_5(long old0, long active0)
707 {
708 if (((active0 &= old0)) == 0L)
709 return jjStartNfa_5(17, old0, 0L);
710 try { curChar = input_stream.readChar(); }
711 catch(java.io.IOException e) {
712 jjStopStringLiteralDfa_5(18, active0, 0L);
713 return 19;
714 }
715 switch(curChar)
716 {
717 case 110:
718 return jjMoveStringLiteralDfa20_5(active0, 0x40000L);
719 default :
720 break;
721 }
722 return jjStartNfa_5(18, active0, 0L);
723 }
724 static private final int jjMoveStringLiteralDfa20_5(long old0, long active0)
725 {
726 if (((active0 &= old0)) == 0L)
727 return jjStartNfa_5(18, old0, 0L);
728 try { curChar = input_stream.readChar(); }
729 catch(java.io.IOException e) {
730 jjStopStringLiteralDfa_5(19, active0, 0L);
731 return 20;
732 }
733 switch(curChar)
734 {
735 case 40:
736 if ((active0 & 0x40000L) != 0L)
737 return jjStopAtPos(20, 18);
738 break;
739 default :
740 break;
741 }
742 return jjStartNfa_5(19, active0, 0L);
743 }
744 static private final void jjCheckNAdd(int state)
745 {
746 if (jjrounds[state] != jjround)
747 {
748 jjstateSet[jjnewStateCnt++] = state;
749 jjrounds[state] = jjround;
750 }
751 }
752 static private final void jjAddStates(int start, int end)
753 {
754 do {
755 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
756 } while (start++ != end);
757 }
758 static private final void jjCheckNAddTwoStates(int state1, int state2)
759 {
760 jjCheckNAdd(state1);
761 jjCheckNAdd(state2);
762 }
763 static private final void jjCheckNAddStates(int start, int end)
764 {
765 do {
766 jjCheckNAdd(jjnextStates[start]);
767 } while (start++ != end);
768 }
769 static private final void jjCheckNAddStates(int start)
770 {
771 jjCheckNAdd(jjnextStates[start]);
772 jjCheckNAdd(jjnextStates[start + 1]);
773 }
774 static private final int jjMoveNfa_5(int startState, int curPos)
775 {
776 int[] nextStates;
777 int startsAt = 0;
778 jjnewStateCnt = 22;
779 int i = 1;
780 jjstateSet[0] = startState;
781 int j, kind = 0x7fffffff;
782 for (;;)
783 {
784 if (++jjround == 0x7fffffff)
785 ReInitRounds();
786 if (curChar < 64)
787 {
788 long l = 1L << curChar;
789 MatchLoop: do
790 {
791 switch(jjstateSet[--i])
792 {
793 case 5:
794 if ((0x3ff401000000000L & l) != 0L)
795 {
796 if (kind > 28)
797 kind = 28;
798 jjCheckNAdd(21);
799 }
800 else if (curChar == 40)
801 {
802 if (kind > 27)
803 kind = 27;
804 }
805 if ((0x3ff401000000000L & l) != 0L)
806 jjCheckNAddTwoStates(19, 20);
807 break;
808 case 22:
809 if ((0x3ff401000000000L & l) != 0L)
810 {
811 if (kind > 28)
812 kind = 28;
813 jjCheckNAdd(21);
814 }
815 else if (curChar == 40)
816 {
817 if (kind > 27)
818 kind = 27;
819 }
820 if ((0x3ff401000000000L & l) != 0L)
821 jjCheckNAddTwoStates(19, 20);
822 break;
823 case 1:
824 if ((0x3ff401000000000L & l) != 0L)
825 {
826 if (kind > 28)
827 kind = 28;
828 jjCheckNAdd(21);
829 }
830 else if (curChar == 40)
831 {
832 if (kind > 27)
833 kind = 27;
834 }
835 if ((0x3ff401000000000L & l) != 0L)
836 jjCheckNAddTwoStates(19, 20);
837 if (curChar == 46)
838 {
839 if (kind > 7)
840 kind = 7;
841 }
842 break;
843 case 0:
844 if ((0x3ff401000000000L & l) != 0L)
845 {
846 if (kind > 28)
847 kind = 28;
848 jjCheckNAddStates(0, 2);
849 }
850 else if (curChar == 38)
851 {
852 if (kind > 8)
853 kind = 8;
854 }
855 if (curChar == 38)
856 jjstateSet[jjnewStateCnt++] = 2;
857 else if (curChar == 46)
858 jjstateSet[jjnewStateCnt++] = 1;
859 break;
860 case 2:
861 if (curChar == 38 && kind > 8)
862 kind = 8;
863 break;
864 case 3:
865 if (curChar == 38)
866 jjstateSet[jjnewStateCnt++] = 2;
867 break;
868 case 10:
869 if (curChar == 38 && kind > 8)
870 kind = 8;
871 break;
872 case 18:
873 if ((0x3ff401000000000L & l) == 0L)
874 break;
875 if (kind > 28)
876 kind = 28;
877 jjCheckNAddStates(0, 2);
878 break;
879 case 19:
880 if ((0x3ff401000000000L & l) != 0L)
881 jjCheckNAddTwoStates(19, 20);
882 break;
883 case 20:
884 if (curChar == 40)
885 kind = 27;
886 break;
887 case 21:
888 if ((0x3ff401000000000L & l) == 0L)
889 break;
890 if (kind > 28)
891 kind = 28;
892 jjCheckNAdd(21);
893 break;
894 default : break;
895 }
896 } while(i != startsAt);
897 }
898 else if (curChar < 128)
899 {
900 long l = 1L << (curChar & 077);
901 MatchLoop: do
902 {
903 switch(jjstateSet[--i])
904 {
905 case 5:
906 if ((0x7fffffe87fffffeL & l) != 0L)
907 {
908 if (kind > 28)
909 kind = 28;
910 jjCheckNAdd(21);
911 }
912 if ((0x7fffffe87fffffeL & l) != 0L)
913 jjCheckNAddTwoStates(19, 20);
914 if (curChar == 110)
915 jjstateSet[jjnewStateCnt++] = 4;
916 break;
917 case 22:
918 if ((0x7fffffe87fffffeL & l) != 0L)
919 {
920 if (kind > 28)
921 kind = 28;
922 jjCheckNAdd(21);
923 }
924 if ((0x7fffffe87fffffeL & l) != 0L)
925 jjCheckNAddTwoStates(19, 20);
926 break;
927 case 1:
928 if ((0x7fffffe87fffffeL & l) != 0L)
929 {
930 if (kind > 28)
931 kind = 28;
932 jjCheckNAdd(21);
933 }
934 if ((0x7fffffe87fffffeL & l) != 0L)
935 jjCheckNAddTwoStates(19, 20);
936 break;
937 case 0:
938 if ((0x7fffffe87fffffeL & l) != 0L)
939 {
940 if (kind > 28)
941 kind = 28;
942 jjCheckNAddStates(0, 2);
943 }
944 else if (curChar == 124)
945 {
946 if (kind > 9)
947 kind = 9;
948 }
949 if (curChar == 79)
950 jjstateSet[jjnewStateCnt++] = 15;
951 else if (curChar == 111)
952 jjstateSet[jjnewStateCnt++] = 13;
953 else if (curChar == 124)
954 jjstateSet[jjnewStateCnt++] = 11;
955 else if (curChar == 65)
956 jjstateSet[jjnewStateCnt++] = 8;
957 else if (curChar == 97)
958 jjstateSet[jjnewStateCnt++] = 5;
959 break;
960 case 4:
961 if (curChar == 100 && kind > 8)
962 kind = 8;
963 break;
964 case 6:
965 if (curChar == 97)
966 jjstateSet[jjnewStateCnt++] = 5;
967 break;
968 case 7:
969 if (curChar == 68 && kind > 8)
970 kind = 8;
971 break;
972 case 8:
973 if (curChar == 78)
974 jjstateSet[jjnewStateCnt++] = 7;
975 break;
976 case 9:
977 if (curChar == 65)
978 jjstateSet[jjnewStateCnt++] = 8;
979 break;
980 case 11:
981 if (curChar == 124 && kind > 9)
982 kind = 9;
983 break;
984 case 12:
985 if (curChar == 124)
986 jjstateSet[jjnewStateCnt++] = 11;
987 break;
988 case 13:
989 if (curChar == 114 && kind > 9)
990 kind = 9;
991 break;
992 case 14:
993 if (curChar == 111)
994 jjstateSet[jjnewStateCnt++] = 13;
995 break;
996 case 15:
997 if (curChar == 82 && kind > 9)
998 kind = 9;
999 break;
1000 case 16:
1001 if (curChar == 79)
1002 jjstateSet[jjnewStateCnt++] = 15;
1003 break;
1004 case 17:
1005 if (curChar == 124 && kind > 9)
1006 kind = 9;
1007 break;
1008 case 18:
1009 if ((0x7fffffe87fffffeL & l) == 0L)
1010 break;
1011 if (kind > 28)
1012 kind = 28;
1013 jjCheckNAddStates(0, 2);
1014 break;
1015 case 19:
1016 if ((0x7fffffe87fffffeL & l) != 0L)
1017 jjCheckNAddTwoStates(19, 20);
1018 break;
1019 case 21:
1020 if ((0x7fffffe87fffffeL & l) == 0L)
1021 break;
1022 if (kind > 28)
1023 kind = 28;
1024 jjCheckNAdd(21);
1025 break;
1026 default : break;
1027 }
1028 } while(i != startsAt);
1029 }
1030 else
1031 {
1032 int i2 = (curChar & 0xff) >> 6;
1033 long l2 = 1L << (curChar & 077);
1034 MatchLoop: do
1035 {
1036 switch(jjstateSet[--i])
1037 {
1038 default : break;
1039 }
1040 } while(i != startsAt);
1041 }
1042 if (kind != 0x7fffffff)
1043 {
1044 jjmatchedKind = kind;
1045 jjmatchedPos = curPos;
1046 kind = 0x7fffffff;
1047 }
1048 ++curPos;
1049 if ((i = jjnewStateCnt) == (startsAt = 22 - (jjnewStateCnt = startsAt)))
1050 return curPos;
1051 try { curChar = input_stream.readChar(); }
1052 catch(java.io.IOException e) { return curPos; }
1053 }
1054}
1055private static final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
1056{
1057 switch (pos)
1058 {
1059 default :
1060 return -1;
1061 }
1062}
1063private static final int jjStartNfa_0(int pos, long active0, long active1)
1064{
1065 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
1066}
1067static private final int jjStartNfaWithStates_0(int pos, int kind, int state)
1068{
1069 jjmatchedKind = kind;
1070 jjmatchedPos = pos;
1071 try { curChar = input_stream.readChar(); }
1072 catch(java.io.IOException e) { return pos + 1; }
1073 return jjMoveNfa_0(state, pos + 1);
1074}
1075static private final int jjMoveStringLiteralDfa0_0()
1076{
1077 switch(curChar)
1078 {
1079 case 41:
1080 return jjStopAtPos(0, 85);
1081 case 44:
1082 return jjStopAtPos(0, 3);
1083 case 46:
1084 return jjStartNfaWithStates_0(0, 4, 1);
1085 default :
1086 return jjMoveNfa_0(0, 0);
1087 }
1088}
1089static private final int jjMoveNfa_0(int startState, int curPos)
1090{
1091 int[] nextStates;
1092 int startsAt = 0;
1093 jjnewStateCnt = 11;
1094 int i = 1;
1095 jjstateSet[0] = startState;
1096 int j, kind = 0x7fffffff;
1097 for (;;)
1098 {
1099 if (++jjround == 0x7fffffff)
1100 ReInitRounds();
1101 if (curChar < 64)
1102 {
1103 long l = 1L << curChar;
1104 MatchLoop: do
1105 {
1106 switch(jjstateSet[--i])
1107 {
1108 case 0:
1109 if ((0x3ff081800000000L & l) != 0L)
1110 {
1111 if (kind > 82)
1112 kind = 82;
1113 jjCheckNAddStates(3, 7);
1114 }
1115 else if (curChar == 46)
1116 jjstateSet[jjnewStateCnt++] = 1;
1117 break;
1118 case 1:
1119 if (curChar == 46 && kind > 7)
1120 kind = 7;
1121 break;
1122 case 2:
1123 if ((0x3ff081800000000L & l) == 0L)
1124 break;
1125 if (kind > 82)
1126 kind = 82;
1127 jjCheckNAddStates(3, 7);
1128 break;
1129 case 3:
1130 if ((0x3ff081800000000L & l) == 0L)
1131 break;
1132 if (kind > 82)
1133 kind = 82;
1134 jjCheckNAddTwoStates(3, 4);
1135 break;
1136 case 4:
1137 if (curChar == 46)
1138 jjCheckNAdd(5);
1139 break;
1140 case 5:
1141 if ((0x3ff081800000000L & l) == 0L)
1142 break;
1143 if (kind > 82)
1144 kind = 82;
1145 jjCheckNAddTwoStates(4, 5);
1146 break;
1147 case 6:
1148 if ((0x3ff081800000000L & l) == 0L)
1149 break;
1150 if (kind > 83)
1151 kind = 83;
1152 jjCheckNAddStates(8, 10);
1153 break;
1154 case 7:
1155 if (curChar == 46)
1156 jjCheckNAdd(8);
1157 break;
1158 case 8:
1159 if ((0x3ff081800000000L & l) == 0L)
1160 break;
1161 if (kind > 83)
1162 kind = 83;
1163 jjCheckNAddStates(11, 13);
1164 break;
1165 default : break;
1166 }
1167 } while(i != startsAt);
1168 }
1169 else if (curChar < 128)
1170 {
1171 long l = 1L << (curChar & 077);
1172 MatchLoop: do
1173 {
1174 switch(jjstateSet[--i])
1175 {
1176 case 0:
1177 if ((0x7fffffe87fffffeL & l) == 0L)
1178 break;
1179 if (kind > 82)
1180 kind = 82;
1181 jjCheckNAddStates(3, 7);
1182 break;
1183 case 3:
1184 if ((0x7fffffe87fffffeL & l) == 0L)
1185 break;
1186 if (kind > 82)
1187 kind = 82;
1188 jjCheckNAddTwoStates(3, 4);
1189 break;
1190 case 5:
1191 if ((0x7fffffe87fffffeL & l) == 0L)
1192 break;
1193 if (kind > 82)
1194 kind = 82;
1195 jjCheckNAddTwoStates(4, 5);
1196 break;
1197 case 6:
1198 if ((0x7fffffe87fffffeL & l) == 0L)
1199 break;
1200 if (kind > 83)
1201 kind = 83;
1202 jjCheckNAddStates(8, 10);
1203 break;
1204 case 8:
1205 if ((0x7fffffe87fffffeL & l) == 0L)
1206 break;
1207 if (kind > 83)
1208 kind = 83;
1209 jjCheckNAddStates(11, 13);
1210 break;
1211 case 9:
1212 if (curChar != 93)
1213 break;
1214 kind = 83;
1215 jjCheckNAdd(10);
1216 break;
1217 case 10:
1218 if (curChar == 91)
1219 jjstateSet[jjnewStateCnt++] = 9;
1220 break;
1221 default : break;
1222 }
1223 } while(i != startsAt);
1224 }
1225 else
1226 {
1227 int i2 = (curChar & 0xff) >> 6;
1228 long l2 = 1L << (curChar & 077);
1229 MatchLoop: do
1230 {
1231 switch(jjstateSet[--i])
1232 {
1233 default : break;
1234 }
1235 } while(i != startsAt);
1236 }
1237 if (kind != 0x7fffffff)
1238 {
1239 jjmatchedKind = kind;
1240 jjmatchedPos = curPos;
1241 kind = 0x7fffffff;
1242 }
1243 ++curPos;
1244 if ((i = jjnewStateCnt) == (startsAt = 11 - (jjnewStateCnt = startsAt)))
1245 return curPos;
1246 try { curChar = input_stream.readChar(); }
1247 catch(java.io.IOException e) { return curPos; }
1248 }
1249}
1250private static final int jjStopStringLiteralDfa_4(int pos, long active0)
1251{
1252 switch (pos)
1253 {
1254 case 0:
1255 if ((active0 & 0x10L) != 0L)
1256 return 12;
1257 if ((active0 & 0x7e0000000L) != 0L)
1258 {
1259 jjmatchedKind = 37;
1260 return 13;
1261 }
1262 return -1;
1263 case 1:
1264 if ((active0 & 0x7e0000000L) != 0L)
1265 {
1266 jjmatchedKind = 37;
1267 jjmatchedPos = 1;
1268 return 13;
1269 }
1270 return -1;
1271 case 2:
1272 if ((active0 & 0x7e0000000L) != 0L)
1273 {
1274 jjmatchedKind = 37;
1275 jjmatchedPos = 2;
1276 return 13;
1277 }
1278 return -1;
1279 case 3:
1280 if ((active0 & 0x7e0000000L) != 0L)
1281 {
1282 jjmatchedKind = 37;
1283 jjmatchedPos = 3;
1284 return 13;
1285 }
1286 return -1;
1287 case 4:
1288 if ((active0 & 0x3e0000000L) != 0L)
1289 {
1290 jjmatchedKind = 37;
1291 jjmatchedPos = 4;
1292 return 13;
1293 }
1294 if ((active0 & 0x400000000L) != 0L)
1295 return 13;
1296 return -1;
1297 case 5:
1298 if ((active0 & 0x180000000L) != 0L)
1299 return 13;
1300 if ((active0 & 0x260000000L) != 0L)
1301 {
1302 jjmatchedKind = 37;
1303 jjmatchedPos = 5;
1304 return 13;
1305 }
1306 return -1;
1307 case 6:
1308 if ((active0 & 0x240000000L) != 0L)
1309 {
1310 jjmatchedKind = 37;
1311 jjmatchedPos = 6;
1312 return 13;
1313 }
1314 if ((active0 & 0x20000000L) != 0L)
1315 return 13;
1316 return -1;
1317 case 7:
1318 if ((active0 & 0x200000000L) != 0L)
1319 return 13;
1320 if ((active0 & 0x40000000L) != 0L)
1321 {
1322 jjmatchedKind = 37;
1323 jjmatchedPos = 7;
1324 return 13;
1325 }
1326 return -1;
1327 default :
1328 return -1;
1329 }
1330}
1331private static final int jjStartNfa_4(int pos, long active0)
1332{
1333 return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
1334}
1335static private final int jjStartNfaWithStates_4(int pos, int kind, int state)
1336{
1337 jjmatchedKind = kind;
1338 jjmatchedPos = pos;
1339 try { curChar = input_stream.readChar(); }
1340 catch(java.io.IOException e) { return pos + 1; }
1341 return jjMoveNfa_4(state, pos + 1);
1342}
1343static private final int jjMoveStringLiteralDfa0_4()
1344{
1345 switch(curChar)
1346 {
1347 case 33:
1348 return jjStopAtPos(0, 35);
1349 case 41:
1350 return jjStopAtPos(0, 41);
1351 case 44:
1352 return jjStopAtPos(0, 3);
1353 case 46:
1354 return jjStartNfaWithStates_4(0, 4, 12);
1355 case 97:
1356 return jjMoveStringLiteralDfa1_4(0x200000000L);
1357 case 102:
1358 return jjMoveStringLiteralDfa1_4(0x400000000L);
1359 case 112:
1360 return jjMoveStringLiteralDfa1_4(0xe0000000L);
1361 case 115:
1362 return jjMoveStringLiteralDfa1_4(0x100000000L);
1363 default :
1364 return jjMoveNfa_4(0, 0);
1365 }
1366}
1367static private final int jjMoveStringLiteralDfa1_4(long active0)
1368{
1369 try { curChar = input_stream.readChar(); }
1370 catch(java.io.IOException e) {
1371 jjStopStringLiteralDfa_4(0, active0);
1372 return 1;
1373 }
1374 switch(curChar)
1375 {
1376 case 98:
1377 return jjMoveStringLiteralDfa2_4(active0, 0x200000000L);
1378 case 105:
1379 return jjMoveStringLiteralDfa2_4(active0, 0x400000000L);
1380 case 114:
1381 return jjMoveStringLiteralDfa2_4(active0, 0x60000000L);
1382 case 116:
1383 return jjMoveStringLiteralDfa2_4(active0, 0x100000000L);
1384 case 117:
1385 return jjMoveStringLiteralDfa2_4(active0, 0x80000000L);
1386 default :
1387 break;
1388 }
1389 return jjStartNfa_4(0, active0);
1390}
1391static private final int jjMoveStringLiteralDfa2_4(long old0, long active0)
1392{
1393 if (((active0 &= old0)) == 0L)
1394 return jjStartNfa_4(0, old0);
1395 try { curChar = input_stream.readChar(); }
1396 catch(java.io.IOException e) {
1397 jjStopStringLiteralDfa_4(1, active0);
1398 return 2;
1399 }
1400 switch(curChar)
1401 {
1402 case 97:
1403 return jjMoveStringLiteralDfa3_4(active0, 0x100000000L);
1404 case 98:
1405 return jjMoveStringLiteralDfa3_4(active0, 0x80000000L);
1406 case 105:
1407 return jjMoveStringLiteralDfa3_4(active0, 0x20000000L);
1408 case 110:
1409 return jjMoveStringLiteralDfa3_4(active0, 0x400000000L);
1410 case 111:
1411 return jjMoveStringLiteralDfa3_4(active0, 0x40000000L);
1412 case 115:
1413 return jjMoveStringLiteralDfa3_4(active0, 0x200000000L);
1414 default :
1415 break;
1416 }
1417 return jjStartNfa_4(1, active0);
1418}
1419static private final int jjMoveStringLiteralDfa3_4(long old0, long active0)
1420{
1421 if (((active0 &= old0)) == 0L)
1422 return jjStartNfa_4(1, old0);
1423 try { curChar = input_stream.readChar(); }
1424 catch(java.io.IOException e) {
1425 jjStopStringLiteralDfa_4(2, active0);
1426 return 3;
1427 }
1428 switch(curChar)
1429 {
1430 case 97:
1431 return jjMoveStringLiteralDfa4_4(active0, 0x400000000L);
1432 case 108:
1433 return jjMoveStringLiteralDfa4_4(active0, 0x80000000L);
1434 case 116:
1435 return jjMoveStringLiteralDfa4_4(active0, 0x340000000L);
1436 case 118:
1437 return jjMoveStringLiteralDfa4_4(active0, 0x20000000L);
1438 default :
1439 break;
1440 }
1441 return jjStartNfa_4(2, active0);
1442}
1443static private final int jjMoveStringLiteralDfa4_4(long old0, long active0)
1444{
1445 if (((active0 &= old0)) == 0L)
1446 return jjStartNfa_4(2, old0);
1447 try { curChar = input_stream.readChar(); }
1448 catch(java.io.IOException e) {
1449 jjStopStringLiteralDfa_4(3, active0);
1450 return 4;
1451 }
1452 switch(curChar)
1453 {
1454 case 97:
1455 return jjMoveStringLiteralDfa5_4(active0, 0x20000000L);
1456 case 101:
1457 return jjMoveStringLiteralDfa5_4(active0, 0x40000000L);
1458 case 105:
1459 return jjMoveStringLiteralDfa5_4(active0, 0x180000000L);
1460 case 108:
1461 if ((active0 & 0x400000000L) != 0L)
1462 return jjStartNfaWithStates_4(4, 34, 13);
1463 break;
1464 case 114:
1465 return jjMoveStringLiteralDfa5_4(active0, 0x200000000L);
1466 default :
1467 break;
1468 }
1469 return jjStartNfa_4(3, active0);
1470}
1471static private final int jjMoveStringLiteralDfa5_4(long old0, long active0)
1472{
1473 if (((active0 &= old0)) == 0L)
1474 return jjStartNfa_4(3, old0);
1475 try { curChar = input_stream.readChar(); }
1476 catch(java.io.IOException e) {
1477 jjStopStringLiteralDfa_4(4, active0);
1478 return 5;
1479 }
1480 switch(curChar)
1481 {
1482 case 97:
1483 return jjMoveStringLiteralDfa6_4(active0, 0x200000000L);
1484 case 99:
1485 if ((active0 & 0x80000000L) != 0L)
1486 return jjStartNfaWithStates_4(5, 31, 13);
1487 else if ((active0 & 0x100000000L) != 0L)
1488 return jjStartNfaWithStates_4(5, 32, 13);
1489 return jjMoveStringLiteralDfa6_4(active0, 0x40000000L);
1490 case 116:
1491 return jjMoveStringLiteralDfa6_4(active0, 0x20000000L);
1492 default :
1493 break;
1494 }
1495 return jjStartNfa_4(4, active0);
1496}
1497static private final int jjMoveStringLiteralDfa6_4(long old0, long active0)
1498{
1499 if (((active0 &= old0)) == 0L)
1500 return jjStartNfa_4(4, old0);
1501 try { curChar = input_stream.readChar(); }
1502 catch(java.io.IOException e) {
1503 jjStopStringLiteralDfa_4(5, active0);
1504 return 6;
1505 }
1506 switch(curChar)
1507 {
1508 case 99:
1509 return jjMoveStringLiteralDfa7_4(active0, 0x200000000L);
1510 case 101:
1511 if ((active0 & 0x20000000L) != 0L)
1512 return jjStartNfaWithStates_4(6, 29, 13);
1513 break;
1514 case 116:
1515 return jjMoveStringLiteralDfa7_4(active0, 0x40000000L);
1516 default :
1517 break;
1518 }
1519 return jjStartNfa_4(5, active0);
1520}
1521static private final int jjMoveStringLiteralDfa7_4(long old0, long active0)
1522{
1523 if (((active0 &= old0)) == 0L)
1524 return jjStartNfa_4(5, old0);
1525 try { curChar = input_stream.readChar(); }
1526 catch(java.io.IOException e) {
1527 jjStopStringLiteralDfa_4(6, active0);
1528 return 7;
1529 }
1530 switch(curChar)
1531 {
1532 case 101:
1533 return jjMoveStringLiteralDfa8_4(active0, 0x40000000L);
1534 case 116:
1535 if ((active0 & 0x200000000L) != 0L)
1536 return jjStartNfaWithStates_4(7, 33, 13);
1537 break;
1538 default :
1539 break;
1540 }
1541 return jjStartNfa_4(6, active0);
1542}
1543static private final int jjMoveStringLiteralDfa8_4(long old0, long active0)
1544{
1545 if (((active0 &= old0)) == 0L)
1546 return jjStartNfa_4(6, old0);
1547 try { curChar = input_stream.readChar(); }
1548 catch(java.io.IOException e) {
1549 jjStopStringLiteralDfa_4(7, active0);
1550 return 8;
1551 }
1552 switch(curChar)
1553 {
1554 case 100:
1555 if ((active0 & 0x40000000L) != 0L)
1556 return jjStartNfaWithStates_4(8, 30, 13);
1557 break;
1558 default :
1559 break;
1560 }
1561 return jjStartNfa_4(7, active0);
1562}
1563static private final int jjMoveNfa_4(int startState, int curPos)
1564{
1565 int[] nextStates;
1566 int startsAt = 0;
1567 jjnewStateCnt = 13;
1568 int i = 1;
1569 jjstateSet[0] = startState;
1570 int j, kind = 0x7fffffff;
1571 for (;;)
1572 {
1573 if (++jjround == 0x7fffffff)
1574 ReInitRounds();
1575 if (curChar < 64)
1576 {
1577 long l = 1L << curChar;
1578 MatchLoop: do
1579 {
1580 switch(jjstateSet[--i])
1581 {
1582 case 13:
1583 if ((0x3ff0c1800000000L & l) != 0L)
1584 {
1585 if (kind > 37)
1586 kind = 37;
1587 jjCheckNAddTwoStates(4, 5);
1588 }
1589 else if (curChar == 46)
1590 jjCheckNAddStates(14, 16);
1591 break;
1592 case 12:
1593 if (curChar == 46)
1594 {
1595 if (kind > 37)
1596 kind = 37;
1597 jjCheckNAddTwoStates(4, 5);
1598 }
1599 if (curChar == 46)
1600 {
1601 if (kind > 7)
1602 kind = 7;
1603 }
1604 break;
1605 case 0:
1606 if ((0x3ff0c1800000000L & l) != 0L)
1607 {
1608 if (kind > 37)
1609 kind = 37;
1610 jjCheckNAddTwoStates(4, 5);
1611 }
1612 else if (curChar == 46)
1613 jjCheckNAddTwoStates(12, 6);
1614 break;
1615 case 1:
1616 if ((0x3ff081800000000L & l) == 0L)
1617 break;
1618 if (kind > 36)
1619 kind = 36;
1620 jjCheckNAddTwoStates(1, 2);
1621 break;
1622 case 2:
1623 if (curChar == 46)
1624 jjCheckNAdd(3);
1625 break;
1626 case 3:
1627 if ((0x3ff081800000000L & l) == 0L)
1628 break;
1629 if (kind > 36)
1630 kind = 36;
1631 jjCheckNAddTwoStates(2, 3);
1632 break;
1633 case 4:
1634 if ((0x3ff0c1800000000L & l) == 0L)
1635 break;
1636 if (kind > 37)
1637 kind = 37;
1638 jjCheckNAddTwoStates(4, 5);
1639 break;
1640 case 5:
1641 if (curChar == 46)
1642 jjCheckNAddStates(14, 16);
1643 break;
1644 case 6:
1645 if (curChar != 46)
1646 break;
1647 if (kind > 37)
1648 kind = 37;
1649 jjCheckNAddTwoStates(4, 5);
1650 break;
1651 case 7:
1652 if ((0x3ff0c1800000000L & l) == 0L)
1653 break;
1654 if (kind > 37)
1655 kind = 37;
1656 jjCheckNAddTwoStates(7, 8);
1657 break;
1658 case 8:
1659 if (curChar == 46)
1660 jjCheckNAddStates(17, 19);
1661 break;
1662 case 9:
1663 if (curChar == 46)
1664 jjCheckNAdd(10);
1665 break;
1666 case 10:
1667 if (curChar != 46)
1668 break;
1669 if (kind > 37)
1670 kind = 37;
1671 jjCheckNAddTwoStates(7, 8);
1672 break;
1673 case 11:
1674 if (curChar == 46)
1675 jjCheckNAddTwoStates(12, 6);
1676 break;
1677 default : break;
1678 }
1679 } while(i != startsAt);
1680 }
1681 else if (curChar < 128)
1682 {
1683 long l = 1L << (curChar & 077);
1684 MatchLoop: do
1685 {
1686 switch(jjstateSet[--i])
1687 {
1688 case 13:
1689 case 4:
1690 if ((0x7fffffe87fffffeL & l) == 0L)
1691 break;
1692 if (kind > 37)
1693 kind = 37;
1694 jjCheckNAddTwoStates(4, 5);
1695 break;
1696 case 0:
1697 if ((0x7fffffe87fffffeL & l) != 0L)
1698 {
1699 if (kind > 37)
1700 kind = 37;
1701 jjCheckNAddTwoStates(4, 5);
1702 }
1703 else if (curChar == 64)
1704 jjCheckNAdd(1);
1705 break;
1706 case 1:
1707 if ((0x7fffffe87fffffeL & l) == 0L)
1708 break;
1709 if (kind > 36)
1710 kind = 36;
1711 jjCheckNAddTwoStates(1, 2);
1712 break;
1713 case 3:
1714 if ((0x7fffffe87fffffeL & l) == 0L)
1715 break;
1716 if (kind > 36)
1717 kind = 36;
1718 jjCheckNAddTwoStates(2, 3);
1719 break;
1720 case 7:
1721 if ((0x7fffffe87fffffeL & l) == 0L)
1722 break;
1723 if (kind > 37)
1724 kind = 37;
1725 jjAddStates(20, 21);
1726 break;
1727 default : break;
1728 }
1729 } while(i != startsAt);
1730 }
1731 else
1732 {
1733 int i2 = (curChar & 0xff) >> 6;
1734 long l2 = 1L << (curChar & 077);
1735 MatchLoop: do
1736 {
1737 switch(jjstateSet[--i])
1738 {
1739 default : break;
1740 }
1741 } while(i != startsAt);
1742 }
1743 if (kind != 0x7fffffff)
1744 {
1745 jjmatchedKind = kind;
1746 jjmatchedPos = curPos;
1747 kind = 0x7fffffff;
1748 }
1749 ++curPos;
1750 if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
1751 return curPos;
1752 try { curChar = input_stream.readChar(); }
1753 catch(java.io.IOException e) { return curPos; }
1754 }
1755}
1756private static final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
1757{
1758 switch (pos)
1759 {
1760 case 0:
1761 if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x7L) != 0L)
1762 {
1763 jjmatchedKind = 70;
1764 return 23;
1765 }
1766 if ((active0 & 0x10L) != 0L)
1767 return 5;
1768 return -1;
1769 case 1:
1770 if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x7L) != 0L)
1771 {
1772 jjmatchedKind = 70;
1773 jjmatchedPos = 1;
1774 return 23;
1775 }
1776 return -1;
1777 case 2:
1778 if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x7L) != 0L)
1779 {
1780 jjmatchedKind = 70;
1781 jjmatchedPos = 2;
1782 return 23;
1783 }
1784 return -1;
1785 case 3:
1786 if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x7L) != 0L)
1787 {
1788 jjmatchedKind = 70;
1789 jjmatchedPos = 3;
1790 return 23;
1791 }
1792 return -1;
1793 case 4:
1794 if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x5L) != 0L)
1795 {
1796 jjmatchedKind = 70;
1797 jjmatchedPos = 4;
1798 return 23;
1799 }
1800 if ((active1 & 0x2L) != 0L)
1801 return 23;
1802 return -1;
1803 case 5:
1804 if ((active0 & 0x3000000000000000L) != 0L || (active1 & 0x5L) != 0L)
1805 {
1806 jjmatchedKind = 70;
1807 jjmatchedPos = 5;
1808 return 23;
1809 }
1810 if ((active0 & 0xc000000000000000L) != 0L)
1811 return 23;
1812 return -1;
1813 case 6:
1814 if ((active0 & 0x2000000000000000L) != 0L || (active1 & 0x5L) != 0L)
1815 {
1816 jjmatchedKind = 70;
1817 jjmatchedPos = 6;
1818 return 23;
1819 }
1820 if ((active0 & 0x1000000000000000L) != 0L)
1821 return 23;
1822 return -1;
1823 case 7:
1824 if ((active0 & 0x2000000000000000L) != 0L || (active1 & 0x4L) != 0L)
1825 {
1826 jjmatchedKind = 70;
1827 jjmatchedPos = 7;
1828 return 23;
1829 }
1830 if ((active1 & 0x1L) != 0L)
1831 return 23;
1832 return -1;
1833 default :
1834 return -1;
1835 }
1836}
1837private static final int jjStartNfa_2(int pos, long active0, long active1)
1838{
1839 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
1840}
1841static private final int jjStartNfaWithStates_2(int pos, int kind, int state)
1842{
1843 jjmatchedKind = kind;
1844 jjmatchedPos = pos;
1845 try { curChar = input_stream.readChar(); }
1846 catch(java.io.IOException e) { return pos + 1; }
1847 return jjMoveNfa_2(state, pos + 1);
1848}
1849static private final int jjMoveStringLiteralDfa0_2()
1850{
1851 switch(curChar)
1852 {
1853 case 33:
1854 return jjStopAtPos(0, 67);
1855 case 41:
1856 return jjStopAtPos(0, 74);
1857 case 44:
1858 return jjStopAtPos(0, 3);
1859 case 46:
1860 return jjStartNfaWithStates_2(0, 4, 5);
1861 case 97:
1862 return jjMoveStringLiteralDfa1_2(0x0L, 0x1L);
1863 case 102:
1864 return jjMoveStringLiteralDfa1_2(0x0L, 0x2L);
1865 case 112:
1866 return jjMoveStringLiteralDfa1_2(0x7000000000000000L, 0x0L);
1867 case 115:
1868 return jjMoveStringLiteralDfa1_2(0x8000000000000000L, 0x0L);
1869 case 116:
1870 return jjMoveStringLiteralDfa1_2(0x0L, 0x4L);
1871 default :
1872 return jjMoveNfa_2(0, 0);
1873 }
1874}
1875static private final int jjMoveStringLiteralDfa1_2(long active0, long active1)
1876{
1877 try { curChar = input_stream.readChar(); }
1878 catch(java.io.IOException e) {
1879 jjStopStringLiteralDfa_2(0, active0, active1);
1880 return 1;
1881 }
1882 switch(curChar)
1883 {
1884 case 98:
1885 return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0x1L);
1886 case 105:
1887 return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0x2L);
1888 case 114:
1889 return jjMoveStringLiteralDfa2_2(active0, 0x3000000000000000L, active1, 0x4L);
1890 case 116:
1891 return jjMoveStringLiteralDfa2_2(active0, 0x8000000000000000L, active1, 0L);
1892 case 117:
1893 return jjMoveStringLiteralDfa2_2(active0, 0x4000000000000000L, active1, 0L);
1894 default :
1895 break;
1896 }
1897 return jjStartNfa_2(0, active0, active1);
1898}
1899static private final int jjMoveStringLiteralDfa2_2(long old0, long active0, long old1, long active1)
1900{
1901 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1902 return jjStartNfa_2(0, old0, old1);
1903 try { curChar = input_stream.readChar(); }
1904 catch(java.io.IOException e) {
1905 jjStopStringLiteralDfa_2(1, active0, active1);
1906 return 2;
1907 }
1908 switch(curChar)
1909 {
1910 case 97:
1911 return jjMoveStringLiteralDfa3_2(active0, 0x8000000000000000L, active1, 0x4L);
1912 case 98:
1913 return jjMoveStringLiteralDfa3_2(active0, 0x4000000000000000L, active1, 0L);
1914 case 105:
1915 return jjMoveStringLiteralDfa3_2(active0, 0x1000000000000000L, active1, 0L);
1916 case 110:
1917 return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x2L);
1918 case 111:
1919 return jjMoveStringLiteralDfa3_2(active0, 0x2000000000000000L, active1, 0L);
1920 case 115:
1921 return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x1L);
1922 default :
1923 break;
1924 }
1925 return jjStartNfa_2(1, active0, active1);
1926}
1927static private final int jjMoveStringLiteralDfa3_2(long old0, long active0, long old1, long active1)
1928{
1929 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1930 return jjStartNfa_2(1, old0, old1);
1931 try { curChar = input_stream.readChar(); }
1932 catch(java.io.IOException e) {
1933 jjStopStringLiteralDfa_2(2, active0, active1);
1934 return 3;
1935 }
1936 switch(curChar)
1937 {
1938 case 97:
1939 return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x2L);
1940 case 108:
1941 return jjMoveStringLiteralDfa4_2(active0, 0x4000000000000000L, active1, 0L);
1942 case 110:
1943 return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x4L);
1944 case 116:
1945 return jjMoveStringLiteralDfa4_2(active0, 0xa000000000000000L, active1, 0x1L);
1946 case 118:
1947 return jjMoveStringLiteralDfa4_2(active0, 0x1000000000000000L, active1, 0L);
1948 default :
1949 break;
1950 }
1951 return jjStartNfa_2(2, active0, active1);
1952}
1953static private final int jjMoveStringLiteralDfa4_2(long old0, long active0, long old1, long active1)
1954{
1955 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1956 return jjStartNfa_2(2, old0, old1);
1957 try { curChar = input_stream.readChar(); }
1958 catch(java.io.IOException e) {
1959 jjStopStringLiteralDfa_2(3, active0, active1);
1960 return 4;
1961 }
1962 switch(curChar)
1963 {
1964 case 97:
1965 return jjMoveStringLiteralDfa5_2(active0, 0x1000000000000000L, active1, 0L);
1966 case 101:
1967 return jjMoveStringLiteralDfa5_2(active0, 0x2000000000000000L, active1, 0L);
1968 case 105:
1969 return jjMoveStringLiteralDfa5_2(active0, 0xc000000000000000L, active1, 0L);
1970 case 108:
1971 if ((active1 & 0x2L) != 0L)
1972 return jjStartNfaWithStates_2(4, 65, 23);
1973 break;
1974 case 114:
1975 return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0x1L);
1976 case 115:
1977 return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0x4L);
1978 default :
1979 break;
1980 }
1981 return jjStartNfa_2(3, active0, active1);
1982}
1983static private final int jjMoveStringLiteralDfa5_2(long old0, long active0, long old1, long active1)
1984{
1985 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1986 return jjStartNfa_2(3, old0, old1);
1987 try { curChar = input_stream.readChar(); }
1988 catch(java.io.IOException e) {
1989 jjStopStringLiteralDfa_2(4, active0, active1);
1990 return 5;
1991 }
1992 switch(curChar)
1993 {
1994 case 97:
1995 return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x1L);
1996 case 99:
1997 if ((active0 & 0x4000000000000000L) != 0L)
1998 return jjStartNfaWithStates_2(5, 62, 23);
1999 else if ((active0 & 0x8000000000000000L) != 0L)
2000 return jjStartNfaWithStates_2(5, 63, 23);
2001 return jjMoveStringLiteralDfa6_2(active0, 0x2000000000000000L, active1, 0L);
2002 case 105:
2003 return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x4L);
2004 case 116:
2005 return jjMoveStringLiteralDfa6_2(active0, 0x1000000000000000L, active1, 0L);
2006 default :
2007 break;
2008 }
2009 return jjStartNfa_2(4, active0, active1);
2010}
2011static private final int jjMoveStringLiteralDfa6_2(long old0, long active0, long old1, long active1)
2012{
2013 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2014 return jjStartNfa_2(4, old0, old1);
2015 try { curChar = input_stream.readChar(); }
2016 catch(java.io.IOException e) {
2017 jjStopStringLiteralDfa_2(5, active0, active1);
2018 return 6;
2019 }
2020 switch(curChar)
2021 {
2022 case 99:
2023 return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x1L);
2024 case 101:
2025 if ((active0 & 0x1000000000000000L) != 0L)
2026 return jjStartNfaWithStates_2(6, 60, 23);
2027 return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x4L);
2028 case 116:
2029 return jjMoveStringLiteralDfa7_2(active0, 0x2000000000000000L, active1, 0L);
2030 default :
2031 break;
2032 }
2033 return jjStartNfa_2(5, active0, active1);
2034}
2035static private final int jjMoveStringLiteralDfa7_2(long old0, long active0, long old1, long active1)
2036{
2037 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2038 return jjStartNfa_2(5, old0, old1);
2039 try { curChar = input_stream.readChar(); }
2040 catch(java.io.IOException e) {
2041 jjStopStringLiteralDfa_2(6, active0, active1);
2042 return 7;
2043 }
2044 switch(curChar)
2045 {
2046 case 101:
2047 return jjMoveStringLiteralDfa8_2(active0, 0x2000000000000000L, active1, 0L);
2048 case 110:
2049 return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0x4L);
2050 case 116:
2051 if ((active1 & 0x1L) != 0L)
2052 return jjStartNfaWithStates_2(7, 64, 23);
2053 break;
2054 default :
2055 break;
2056 }
2057 return jjStartNfa_2(6, active0, active1);
2058}
2059static private final int jjMoveStringLiteralDfa8_2(long old0, long active0, long old1, long active1)
2060{
2061 if (((active0 &= old0) | (active1 &= old1)) == 0L)
2062 return jjStartNfa_2(6, old0, old1);
2063 try { curChar = input_stream.readChar(); }
2064 catch(java.io.IOException e) {
2065 jjStopStringLiteralDfa_2(7, active0, active1);
2066 return 8;
2067 }
2068 switch(curChar)
2069 {
2070 case 100:
2071 if ((active0 & 0x2000000000000000L) != 0L)
2072 return jjStartNfaWithStates_2(8, 61, 23);
2073 break;
2074 case 116:
2075 if ((active1 & 0x4L) != 0L)
2076 return jjStartNfaWithStates_2(8, 66, 23);
2077 break;
2078 default :
2079 break;
2080 }
2081 return jjStartNfa_2(7, active0, active1);
2082}
2083static private final int jjMoveNfa_2(int startState, int curPos)
2084{
2085 int[] nextStates;
2086 int startsAt = 0;
2087 jjnewStateCnt = 23;
2088 int i = 1;
2089 jjstateSet[0] = startState;
2090 int j, kind = 0x7fffffff;
2091 for (;;)
2092 {
2093 if (++jjround == 0x7fffffff)
2094 ReInitRounds();
2095 if (curChar < 64)
2096 {
2097 long l = 1L << curChar;
2098 MatchLoop: do
2099 {
2100 switch(jjstateSet[--i])
2101 {
2102 case 5:
2103 if (curChar == 46)
2104 jjCheckNAddStates(22, 24);
2105 if (curChar == 46)
2106 {
2107 if (kind > 70)
2108 kind = 70;
2109 jjCheckNAddTwoStates(7, 8);
2110 }
2111 if (curChar == 46)
2112 {
2113 if (kind > 7)
2114 kind = 7;
2115 }
2116 break;
2117 case 23:
2118 if ((0x3ff0c1800000000L & l) != 0L)
2119 jjCheckNAddStates(22, 24);
2120 else if (curChar == 46)
2121 jjCheckNAddStates(25, 27);
2122 if ((0x3ff0c1800000000L & l) != 0L)
2123 {
2124 if (kind > 70)
2125 kind = 70;
2126 jjCheckNAddTwoStates(7, 8);
2127 }
2128 else if (curChar == 46)
2129 jjCheckNAddStates(28, 30);
2130 break;
2131 case 0:
2132 if ((0x3ff0c1800000000L & l) != 0L)
2133 {
2134 if (kind > 70)
2135 kind = 70;
2136 jjCheckNAddStates(31, 35);
2137 }
2138 else if (curChar == 46)
2139 jjCheckNAddStates(36, 38);
2140 break;
2141 case 1:
2142 if ((0x3ff081800000000L & l) == 0L)
2143 break;
2144 if (kind > 68)
2145 kind = 68;
2146 jjCheckNAddTwoStates(1, 2);
2147 break;
2148 case 2:
2149 if (curChar == 46)
2150 jjCheckNAdd(3);
2151 break;
2152 case 3:
2153 if ((0x3ff081800000000L & l) == 0L)
2154 break;
2155 if (kind > 68)
2156 kind = 68;
2157 jjCheckNAddTwoStates(2, 3);
2158 break;
2159 case 4:
2160 if (curChar == 46)
2161 jjCheckNAddStates(36, 38);
2162 break;
2163 case 6:
2164 if (curChar != 46)
2165 break;
2166 if (kind > 70)
2167 kind = 70;
2168 jjCheckNAddTwoStates(7, 8);
2169 break;
2170 case 7:
2171 if ((0x3ff0c1800000000L & l) == 0L)
2172 break;
2173 if (kind > 70)
2174 kind = 70;
2175 jjCheckNAddTwoStates(7, 8);
2176 break;
2177 case 8:
2178 if (curChar == 46)
2179 jjCheckNAddStates(25, 27);
2180 break;
2181 case 9:
2182 if ((0x3ff0c1800000000L & l) == 0L)
2183 break;
2184 if (kind > 70)
2185 kind = 70;
2186 jjCheckNAddTwoStates(9, 10);
2187 break;
2188 case 10:
2189 if (curChar == 46)
2190 jjCheckNAddStates(39, 41);
2191 break;
2192 case 11:
2193 if (curChar == 46)
2194 jjCheckNAdd(12);
2195 break;
2196 case 12:
2197 if (curChar != 46)
2198 break;
2199 if (kind > 70)
2200 kind = 70;
2201 jjCheckNAddTwoStates(9, 10);
2202 break;
2203 case 13:
2204 if (curChar == 46)
2205 jjCheckNAddStates(22, 24);
2206 break;
2207 case 14:
2208 if ((0x3ff0c1800000000L & l) != 0L)
2209 jjCheckNAddStates(22, 24);
2210 break;
2211 case 17:
2212 if (curChar == 46)
2213 jjCheckNAddStates(28, 30);
2214 break;
2215 case 18:
2216 if ((0x3ff0c1800000000L & l) != 0L)
2217 jjCheckNAddStates(42, 44);
2218 break;
2219 case 19:
2220 if (curChar == 46)
2221 jjCheckNAddStates(45, 47);
2222 break;
2223 case 20:
2224 if (curChar == 46)
2225 jjCheckNAdd(21);
2226 break;
2227 case 21:
2228 if (curChar == 46)
2229 jjCheckNAddStates(42, 44);
2230 break;
2231 case 22:
2232 if ((0x3ff0c1800000000L & l) == 0L)
2233 break;
2234 if (kind > 70)
2235 kind = 70;
2236 jjCheckNAddStates(31, 35);
2237 break;
2238 default : break;
2239 }
2240 } while(i != startsAt);
2241 }
2242 else if (curChar < 128)
2243 {
2244 long l = 1L << (curChar & 077);
2245 MatchLoop: do
2246 {
2247 switch(jjstateSet[--i])
2248 {
2249 case 23:
2250 if ((0x7fffffe87fffffeL & l) != 0L)
2251 jjCheckNAddStates(22, 24);
2252 else if (curChar == 91)
2253 jjstateSet[jjnewStateCnt++] = 15;
2254 if ((0x7fffffe87fffffeL & l) != 0L)
2255 {
2256 if (kind > 70)
2257 kind = 70;
2258 jjCheckNAddTwoStates(7, 8);
2259 }
2260 break;
2261 case 0:
2262 if ((0x7fffffe87fffffeL & l) != 0L)
2263 {
2264 if (kind > 70)
2265 kind = 70;
2266 jjCheckNAddStates(31, 35);
2267 }
2268 else if (curChar == 64)
2269 jjCheckNAdd(1);
2270 break;
2271 case 1:
2272 if ((0x7fffffe87fffffeL & l) == 0L)
2273 break;
2274 if (kind > 68)
2275 kind = 68;
2276 jjCheckNAddTwoStates(1, 2);
2277 break;
2278 case 3:
2279 if ((0x7fffffe87fffffeL & l) == 0L)
2280 break;
2281 if (kind > 68)
2282 kind = 68;
2283 jjCheckNAddTwoStates(2, 3);
2284 break;
2285 case 7:
2286 if ((0x7fffffe87fffffeL & l) == 0L)
2287 break;
2288 if (kind > 70)
2289 kind = 70;
2290 jjCheckNAddTwoStates(7, 8);
2291 break;
2292 case 9:
2293 if ((0x7fffffe87fffffeL & l) == 0L)
2294 break;
2295 if (kind > 70)
2296 kind = 70;
2297 jjAddStates(48, 49);
2298 break;
2299 case 14:
2300 if ((0x7fffffe87fffffeL & l) != 0L)
2301 jjCheckNAddStates(22, 24);
2302 break;
2303 case 15:
2304 if (curChar != 93)
2305 break;
2306 kind = 71;
2307 jjCheckNAdd(16);
2308 break;
2309 case 16:
2310 if (curChar == 91)
2311 jjstateSet[jjnewStateCnt++] = 15;
2312 break;
2313 case 18:
2314 if ((0x7fffffe87fffffeL & l) != 0L)
2315 jjCheckNAddStates(42, 44);
2316 break;
2317 case 22:
2318 if ((0x7fffffe87fffffeL & l) == 0L)
2319 break;
2320 if (kind > 70)
2321 kind = 70;
2322 jjCheckNAddStates(31, 35);
2323 break;
2324 default : break;
2325 }
2326 } while(i != startsAt);
2327 }
2328 else
2329 {
2330 int i2 = (curChar & 0xff) >> 6;
2331 long l2 = 1L << (curChar & 077);
2332 MatchLoop: do
2333 {
2334 switch(jjstateSet[--i])
2335 {
2336 default : break;
2337 }
2338 } while(i != startsAt);
2339 }
2340 if (kind != 0x7fffffff)
2341 {
2342 jjmatchedKind = kind;
2343 jjmatchedPos = curPos;
2344 kind = 0x7fffffff;
2345 }
2346 ++curPos;
2347 if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
2348 return curPos;
2349 try { curChar = input_stream.readChar(); }
2350 catch(java.io.IOException e) { return curPos; }
2351 }
2352}
2353private static final int jjStopStringLiteralDfa_3(int pos, long active0)
2354{
2355 switch (pos)
2356 {
2357 case 0:
2358 if ((active0 & 0x10L) != 0L)
2359 return 5;
2360 if ((active0 & 0x7fc0000000000L) != 0L)
2361 {
2362 jjmatchedKind = 54;
2363 return 23;
2364 }
2365 return -1;
2366 case 1:
2367 if ((active0 & 0x7fc0000000000L) != 0L)
2368 {
2369 jjmatchedKind = 54;
2370 jjmatchedPos = 1;
2371 return 23;
2372 }
2373 return -1;
2374 case 2:
2375 if ((active0 & 0x7fc0000000000L) != 0L)
2376 {
2377 jjmatchedKind = 54;
2378 jjmatchedPos = 2;
2379 return 23;
2380 }
2381 return -1;
2382 case 3:
2383 if ((active0 & 0x7fc0000000000L) != 0L)
2384 {
2385 jjmatchedKind = 54;
2386 jjmatchedPos = 3;
2387 return 23;
2388 }
2389 return -1;
2390 case 4:
2391 if ((active0 & 0x77c0000000000L) != 0L)
2392 {
2393 jjmatchedKind = 54;
2394 jjmatchedPos = 4;
2395 return 23;
2396 }
2397 if ((active0 & 0x800000000000L) != 0L)
2398 return 23;
2399 return -1;
2400 case 5:
2401 if ((active0 & 0x2580000000000L) != 0L)
2402 {
2403 if (jjmatchedPos != 5)
2404 {
2405 jjmatchedKind = 54;
2406 jjmatchedPos = 5;
2407 }
2408 return 23;
2409 }
2410 if ((active0 & 0x5240000000000L) != 0L)
2411 return 23;
2412 return -1;
2413 case 6:
2414 if ((active0 & 0x6480000000000L) != 0L)
2415 {
2416 jjmatchedKind = 54;
2417 jjmatchedPos = 6;
2418 return 23;
2419 }
2420 if ((active0 & 0x100000000000L) != 0L)
2421 return 23;
2422 return -1;
2423 case 7:
2424 if ((active0 & 0x6080000000000L) != 0L)
2425 {
2426 jjmatchedKind = 54;
2427 jjmatchedPos = 7;
2428 return 23;
2429 }
2430 if ((active0 & 0x400000000000L) != 0L)
2431 return 23;
2432 return -1;
2433 case 8:
2434 if ((active0 & 0x6000000000000L) != 0L)
2435 {
2436 jjmatchedKind = 54;
2437 jjmatchedPos = 8;
2438 return 23;
2439 }
2440 if ((active0 & 0x80000000000L) != 0L)
2441 return 23;
2442 return -1;
2443 case 9:
2444 if ((active0 & 0x6000000000000L) != 0L)
2445 {
2446 jjmatchedKind = 54;
2447 jjmatchedPos = 9;
2448 return 23;
2449 }
2450 return -1;
2451 case 10:
2452 if ((active0 & 0x6000000000000L) != 0L)
2453 {
2454 jjmatchedKind = 54;
2455 jjmatchedPos = 10;
2456 return 23;
2457 }
2458 return -1;
2459 case 11:
2460 if ((active0 & 0x4000000000000L) != 0L)
2461 {
2462 jjmatchedKind = 54;
2463 jjmatchedPos = 11;
2464 return 23;
2465 }
2466 if ((active0 & 0x2000000000000L) != 0L)
2467 return 23;
2468 return -1;
2469 case 12:
2470 if ((active0 & 0x4000000000000L) != 0L)
2471 {
2472 jjmatchedKind = 54;
2473 jjmatchedPos = 12;
2474 return 23;
2475 }
2476 return -1;
2477 case 13:
2478 if ((active0 & 0x4000000000000L) != 0L)
2479 {
2480 jjmatchedKind = 54;
2481 jjmatchedPos = 13;
2482 return 23;
2483 }
2484 return -1;
2485 case 14:
2486 if ((active0 & 0x4000000000000L) != 0L)
2487 {
2488 jjmatchedKind = 54;
2489 jjmatchedPos = 14;
2490 return 23;
2491 }
2492 return -1;
2493 case 15:
2494 if ((active0 & 0x4000000000000L) != 0L)
2495 {
2496 jjmatchedKind = 54;
2497 jjmatchedPos = 15;
2498 return 23;
2499 }
2500 return -1;
2501 case 16:
2502 if ((active0 & 0x4000000000000L) != 0L)
2503 {
2504 jjmatchedKind = 54;
2505 jjmatchedPos = 16;
2506 return 23;
2507 }
2508 return -1;
2509 case 17:
2510 if ((active0 & 0x4000000000000L) != 0L)
2511 {
2512 jjmatchedKind = 54;
2513 jjmatchedPos = 17;
2514 return 23;
2515 }
2516 return -1;
2517 case 18:
2518 if ((active0 & 0x4000000000000L) != 0L)
2519 {
2520 jjmatchedKind = 54;
2521 jjmatchedPos = 18;
2522 return 23;
2523 }
2524 return -1;
2525 default :
2526 return -1;
2527 }
2528}
2529private static final int jjStartNfa_3(int pos, long active0)
2530{
2531 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
2532}
2533static private final int jjStartNfaWithStates_3(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_3(state, pos + 1);
2540}
2541static private final int jjMoveStringLiteralDfa0_3()
2542{
2543 switch(curChar)
2544 {
2545 case 33:
2546 return jjStopAtPos(0, 51);
2547 case 40:
2548 return jjStopAtPos(0, 57);
2549 case 41:
2550 return jjStopAtPos(0, 58);
2551 case 44:
2552 return jjStopAtPos(0, 3);
2553 case 46:
2554 return jjStartNfaWithStates_3(0, 4, 5);
2555 case 97:
2556 return jjMoveStringLiteralDfa1_3(0x400000000000L);
2557 case 102:
2558 return jjMoveStringLiteralDfa1_3(0x800000000000L);
2559 case 110:
2560 return jjMoveStringLiteralDfa1_3(0x1000000000000L);
2561 case 112:
2562 return jjMoveStringLiteralDfa1_3(0x1c0000000000L);
2563 case 115:
2564 return jjMoveStringLiteralDfa1_3(0x6200000000000L);
2565 default :
2566 return jjMoveNfa_3(0, 0);
2567 }
2568}
2569static private final int jjMoveStringLiteralDfa1_3(long active0)
2570{
2571 try { curChar = input_stream.readChar(); }
2572 catch(java.io.IOException e) {
2573 jjStopStringLiteralDfa_3(0, active0);
2574 return 1;
2575 }
2576 switch(curChar)
2577 {
2578 case 97:
2579 return jjMoveStringLiteralDfa2_3(active0, 0x1000000000000L);
2580 case 98:
2581 return jjMoveStringLiteralDfa2_3(active0, 0x400000000000L);
2582 case 105:
2583 return jjMoveStringLiteralDfa2_3(active0, 0x800000000000L);
2584 case 114:
2585 return jjMoveStringLiteralDfa2_3(active0, 0x180000000000L);
2586 case 116:
2587 return jjMoveStringLiteralDfa2_3(active0, 0x4200000000000L);
2588 case 117:
2589 return jjMoveStringLiteralDfa2_3(active0, 0x40000000000L);
2590 case 121:
2591 return jjMoveStringLiteralDfa2_3(active0, 0x2000000000000L);
2592 default :
2593 break;
2594 }
2595 return jjStartNfa_3(0, active0);
2596}
2597static private final int jjMoveStringLiteralDfa2_3(long old0, long active0)
2598{
2599 if (((active0 &= old0)) == 0L)
2600 return jjStartNfa_3(0, old0);
2601 try { curChar = input_stream.readChar(); }
2602 catch(java.io.IOException e) {
2603 jjStopStringLiteralDfa_3(1, active0);
2604 return 2;
2605 }
2606 switch(curChar)
2607 {
2608 case 97:
2609 return jjMoveStringLiteralDfa3_3(active0, 0x4200000000000L);
2610 case 98:
2611 return jjMoveStringLiteralDfa3_3(active0, 0x40000000000L);
2612 case 105:
2613 return jjMoveStringLiteralDfa3_3(active0, 0x100000000000L);
2614 case 110:
2615 return jjMoveStringLiteralDfa3_3(active0, 0x2800000000000L);
2616 case 111:
2617 return jjMoveStringLiteralDfa3_3(active0, 0x80000000000L);
2618 case 115:
2619 return jjMoveStringLiteralDfa3_3(active0, 0x400000000000L);
2620 case 116:
2621 return jjMoveStringLiteralDfa3_3(active0, 0x1000000000000L);
2622 default :
2623 break;
2624 }
2625 return jjStartNfa_3(1, active0);
2626}
2627static private final int jjMoveStringLiteralDfa3_3(long old0, long active0)
2628{
2629 if (((active0 &= old0)) == 0L)
2630 return jjStartNfa_3(1, old0);
2631 try { curChar = input_stream.readChar(); }
2632 catch(java.io.IOException e) {
2633 jjStopStringLiteralDfa_3(2, active0);
2634 return 3;
2635 }
2636 switch(curChar)
2637 {
2638 case 97:
2639 return jjMoveStringLiteralDfa4_3(active0, 0x800000000000L);
2640 case 99:
2641 return jjMoveStringLiteralDfa4_3(active0, 0x2000000000000L);
2642 case 105:
2643 return jjMoveStringLiteralDfa4_3(active0, 0x1000000000000L);
2644 case 108:
2645 return jjMoveStringLiteralDfa4_3(active0, 0x40000000000L);
2646 case 116:
2647 return jjMoveStringLiteralDfa4_3(active0, 0x4680000000000L);
2648 case 118:
2649 return jjMoveStringLiteralDfa4_3(active0, 0x100000000000L);
2650 default :
2651 break;
2652 }
2653 return jjStartNfa_3(2, active0);
2654}
2655static private final int jjMoveStringLiteralDfa4_3(long old0, long active0)
2656{
2657 if (((active0 &= old0)) == 0L)
2658 return jjStartNfa_3(2, old0);
2659 try { curChar = input_stream.readChar(); }
2660 catch(java.io.IOException e) {
2661 jjStopStringLiteralDfa_3(3, active0);
2662 return 4;
2663 }
2664 switch(curChar)
2665 {
2666 case 97:
2667 return jjMoveStringLiteralDfa5_3(active0, 0x100000000000L);
2668 case 101:
2669 return jjMoveStringLiteralDfa5_3(active0, 0x80000000000L);
2670 case 104:
2671 return jjMoveStringLiteralDfa5_3(active0, 0x2000000000000L);
2672 case 105:
2673 return jjMoveStringLiteralDfa5_3(active0, 0x4240000000000L);
2674 case 108:
2675 if ((active0 & 0x800000000000L) != 0L)
2676 return jjStartNfaWithStates_3(4, 47, 23);
2677 break;
2678 case 114:
2679 return jjMoveStringLiteralDfa5_3(active0, 0x400000000000L);
2680 case 118:
2681 return jjMoveStringLiteralDfa5_3(active0, 0x1000000000000L);
2682 default :
2683 break;
2684 }
2685 return jjStartNfa_3(3, active0);
2686}
2687static private final int jjMoveStringLiteralDfa5_3(long old0, long active0)
2688{
2689 if (((active0 &= old0)) == 0L)
2690 return jjStartNfa_3(3, old0);
2691 try { curChar = input_stream.readChar(); }
2692 catch(java.io.IOException e) {
2693 jjStopStringLiteralDfa_3(4, active0);
2694 return 5;
2695 }
2696 switch(curChar)
2697 {
2698 case 97:
2699 return jjMoveStringLiteralDfa6_3(active0, 0x400000000000L);
2700 case 99:
2701 if ((active0 & 0x40000000000L) != 0L)
2702 return jjStartNfaWithStates_3(5, 42, 23);
2703 else if ((active0 & 0x200000000000L) != 0L)
2704 {
2705 jjmatchedKind = 45;
2706 jjmatchedPos = 5;
2707 }
2708 return jjMoveStringLiteralDfa6_3(active0, 0x4080000000000L);
2709 case 101:
2710 if ((active0 & 0x1000000000000L) != 0L)
2711 return jjStartNfaWithStates_3(5, 48, 23);
2712 break;
2713 case 114:
2714 return jjMoveStringLiteralDfa6_3(active0, 0x2000000000000L);
2715 case 116:
2716 return jjMoveStringLiteralDfa6_3(active0, 0x100000000000L);
2717 default :
2718 break;
2719 }
2720 return jjStartNfa_3(4, active0);
2721}
2722static private final int jjMoveStringLiteralDfa6_3(long old0, long active0)
2723{
2724 if (((active0 &= old0)) == 0L)
2725 return jjStartNfa_3(4, old0);
2726 try { curChar = input_stream.readChar(); }
2727 catch(java.io.IOException e) {
2728 jjStopStringLiteralDfa_3(5, active0);
2729 return 6;
2730 }
2731 switch(curChar)
2732 {
2733 case 99:
2734 return jjMoveStringLiteralDfa7_3(active0, 0x400000000000L);
2735 case 101:
2736 if ((active0 & 0x100000000000L) != 0L)
2737 return jjStartNfaWithStates_3(6, 44, 23);
2738 break;
2739 case 105:
2740 return jjMoveStringLiteralDfa7_3(active0, 0x4000000000000L);
2741 case 111:
2742 return jjMoveStringLiteralDfa7_3(active0, 0x2000000000000L);
2743 case 116:
2744 return jjMoveStringLiteralDfa7_3(active0, 0x80000000000L);
2745 default :
2746 break;
2747 }
2748 return jjStartNfa_3(5, active0);
2749}
2750static private final int jjMoveStringLiteralDfa7_3(long old0, long active0)
2751{
2752 if (((active0 &= old0)) == 0L)
2753 return jjStartNfa_3(5, old0);
2754 try { curChar = input_stream.readChar(); }
2755 catch(java.io.IOException e) {
2756 jjStopStringLiteralDfa_3(6, active0);
2757 return 7;
2758 }
2759 switch(curChar)
2760 {
2761 case 101:
2762 return jjMoveStringLiteralDfa8_3(active0, 0x80000000000L);
2763 case 110:
2764 return jjMoveStringLiteralDfa8_3(active0, 0x6000000000000L);
2765 case 116:
2766 if ((active0 & 0x400000000000L) != 0L)
2767 return jjStartNfaWithStates_3(7, 46, 23);
2768 break;
2769 default :
2770 break;
2771 }
2772 return jjStartNfa_3(6, active0);
2773}
2774static private final int jjMoveStringLiteralDfa8_3(long old0, long active0)
2775{
2776 if (((active0 &= old0)) == 0L)
2777 return jjStartNfa_3(6, old0);
2778 try { curChar = input_stream.readChar(); }
2779 catch(java.io.IOException e) {
2780 jjStopStringLiteralDfa_3(7, active0);
2781 return 8;
2782 }
2783 switch(curChar)
2784 {
2785 case 100:
2786 if ((active0 & 0x80000000000L) != 0L)
2787 return jjStartNfaWithStates_3(8, 43, 23);
2788 break;
2789 case 105:
2790 return jjMoveStringLiteralDfa9_3(active0, 0x6000000000000L);
2791 default :
2792 break;
2793 }
2794 return jjStartNfa_3(7, active0);
2795}
2796static private final int jjMoveStringLiteralDfa9_3(long old0, long active0)
2797{
2798 if (((active0 &= old0)) == 0L)
2799 return jjStartNfa_3(7, old0);
2800 try { curChar = input_stream.readChar(); }
2801 catch(java.io.IOException e) {
2802 jjStopStringLiteralDfa_3(8, active0);
2803 return 9;
2804 }
2805 switch(curChar)
2806 {
2807 case 116:
2808 return jjMoveStringLiteralDfa10_3(active0, 0x4000000000000L);
2809 case 122:
2810 return jjMoveStringLiteralDfa10_3(active0, 0x2000000000000L);
2811 default :
2812 break;
2813 }
2814 return jjStartNfa_3(8, active0);
2815}
2816static private final int jjMoveStringLiteralDfa10_3(long old0, long active0)
2817{
2818 if (((active0 &= old0)) == 0L)
2819 return jjStartNfa_3(8, old0);
2820 try { curChar = input_stream.readChar(); }
2821 catch(java.io.IOException e) {
2822 jjStopStringLiteralDfa_3(9, active0);
2823 return 10;
2824 }
2825 switch(curChar)
2826 {
2827 case 101:
2828 return jjMoveStringLiteralDfa11_3(active0, 0x2000000000000L);
2829 case 105:
2830 return jjMoveStringLiteralDfa11_3(active0, 0x4000000000000L);
2831 default :
2832 break;
2833 }
2834 return jjStartNfa_3(9, active0);
2835}
2836static private final int jjMoveStringLiteralDfa11_3(long old0, long active0)
2837{
2838 if (((active0 &= old0)) == 0L)
2839 return jjStartNfa_3(9, old0);
2840 try { curChar = input_stream.readChar(); }
2841 catch(java.io.IOException e) {
2842 jjStopStringLiteralDfa_3(10, active0);
2843 return 11;
2844 }
2845 switch(curChar)
2846 {
2847 case 97:
2848 return jjMoveStringLiteralDfa12_3(active0, 0x4000000000000L);
2849 case 100:
2850 if ((active0 & 0x2000000000000L) != 0L)
2851 return jjStartNfaWithStates_3(11, 49, 23);
2852 break;
2853 default :
2854 break;
2855 }
2856 return jjStartNfa_3(10, active0);
2857}
2858static private final int jjMoveStringLiteralDfa12_3(long old0, long active0)
2859{
2860 if (((active0 &= old0)) == 0L)
2861 return jjStartNfa_3(10, old0);
2862 try { curChar = input_stream.readChar(); }
2863 catch(java.io.IOException e) {
2864 jjStopStringLiteralDfa_3(11, active0);
2865 return 12;
2866 }
2867 switch(curChar)
2868 {
2869 case 108:
2870 return jjMoveStringLiteralDfa13_3(active0, 0x4000000000000L);
2871 default :
2872 break;
2873 }
2874 return jjStartNfa_3(11, active0);
2875}
2876static private final int jjMoveStringLiteralDfa13_3(long old0, long active0)
2877{
2878 if (((active0 &= old0)) == 0L)
2879 return jjStartNfa_3(11, old0);
2880 try { curChar = input_stream.readChar(); }
2881 catch(java.io.IOException e) {
2882 jjStopStringLiteralDfa_3(12, active0);
2883 return 13;
2884 }
2885 switch(curChar)
2886 {
2887 case 105:
2888 return jjMoveStringLiteralDfa14_3(active0, 0x4000000000000L);
2889 default :
2890 break;
2891 }
2892 return jjStartNfa_3(12, active0);
2893}
2894static private final int jjMoveStringLiteralDfa14_3(long old0, long active0)
2895{
2896 if (((active0 &= old0)) == 0L)
2897 return jjStartNfa_3(12, old0);
2898 try { curChar = input_stream.readChar(); }
2899 catch(java.io.IOException e) {
2900 jjStopStringLiteralDfa_3(13, active0);
2901 return 14;
2902 }
2903 switch(curChar)
2904 {
2905 case 122:
2906 return jjMoveStringLiteralDfa15_3(active0, 0x4000000000000L);
2907 default :
2908 break;
2909 }
2910 return jjStartNfa_3(13, active0);
2911}
2912static private final int jjMoveStringLiteralDfa15_3(long old0, long active0)
2913{
2914 if (((active0 &= old0)) == 0L)
2915 return jjStartNfa_3(13, old0);
2916 try { curChar = input_stream.readChar(); }
2917 catch(java.io.IOException e) {
2918 jjStopStringLiteralDfa_3(14, active0);
2919 return 15;
2920 }
2921 switch(curChar)
2922 {
2923 case 97:
2924 return jjMoveStringLiteralDfa16_3(active0, 0x4000000000000L);
2925 default :
2926 break;
2927 }
2928 return jjStartNfa_3(14, active0);
2929}
2930static private final int jjMoveStringLiteralDfa16_3(long old0, long active0)
2931{
2932 if (((active0 &= old0)) == 0L)
2933 return jjStartNfa_3(14, old0);
2934 try { curChar = input_stream.readChar(); }
2935 catch(java.io.IOException e) {
2936 jjStopStringLiteralDfa_3(15, active0);
2937 return 16;
2938 }
2939 switch(curChar)
2940 {
2941 case 116:
2942 return jjMoveStringLiteralDfa17_3(active0, 0x4000000000000L);
2943 default :
2944 break;
2945 }
2946 return jjStartNfa_3(15, active0);
2947}
2948static private final int jjMoveStringLiteralDfa17_3(long old0, long active0)
2949{
2950 if (((active0 &= old0)) == 0L)
2951 return jjStartNfa_3(15, old0);
2952 try { curChar = input_stream.readChar(); }
2953 catch(java.io.IOException e) {
2954 jjStopStringLiteralDfa_3(16, active0);
2955 return 17;
2956 }
2957 switch(curChar)
2958 {
2959 case 105:
2960 return jjMoveStringLiteralDfa18_3(active0, 0x4000000000000L);
2961 default :
2962 break;
2963 }
2964 return jjStartNfa_3(16, active0);
2965}
2966static private final int jjMoveStringLiteralDfa18_3(long old0, long active0)
2967{
2968 if (((active0 &= old0)) == 0L)
2969 return jjStartNfa_3(16, old0);
2970 try { curChar = input_stream.readChar(); }
2971 catch(java.io.IOException e) {
2972 jjStopStringLiteralDfa_3(17, active0);
2973 return 18;
2974 }
2975 switch(curChar)
2976 {
2977 case 111:
2978 return jjMoveStringLiteralDfa19_3(active0, 0x4000000000000L);
2979 default :
2980 break;
2981 }
2982 return jjStartNfa_3(17, active0);
2983}
2984static private final int jjMoveStringLiteralDfa19_3(long old0, long active0)
2985{
2986 if (((active0 &= old0)) == 0L)
2987 return jjStartNfa_3(17, old0);
2988 try { curChar = input_stream.readChar(); }
2989 catch(java.io.IOException e) {
2990 jjStopStringLiteralDfa_3(18, active0);
2991 return 19;
2992 }
2993 switch(curChar)
2994 {
2995 case 110:
2996 if ((active0 & 0x4000000000000L) != 0L)
2997 return jjStartNfaWithStates_3(19, 50, 23);
2998 break;
2999 default :
3000 break;
3001 }
3002 return jjStartNfa_3(18, active0);
3003}
3004static private final int jjMoveNfa_3(int startState, int curPos)
3005{
3006 int[] nextStates;
3007 int startsAt = 0;
3008 jjnewStateCnt = 23;
3009 int i = 1;
3010 jjstateSet[0] = startState;
3011 int j, kind = 0x7fffffff;
3012 for (;;)
3013 {
3014 if (++jjround == 0x7fffffff)
3015 ReInitRounds();
3016 if (curChar < 64)
3017 {
3018 long l = 1L << curChar;
3019 MatchLoop: do
3020 {
3021 switch(jjstateSet[--i])
3022 {
3023 case 5:
3024 if (curChar == 46)
3025 jjCheckNAddStates(22, 24);
3026 if (curChar == 46)
3027 {
3028 if (kind > 54)
3029 kind = 54;
3030 jjCheckNAddTwoStates(7, 8);
3031 }
3032 if (curChar == 46)
3033 {
3034 if (kind > 7)
3035 kind = 7;
3036 }
3037 break;
3038 case 23:
3039 if ((0x3ff0c1800000000L & l) != 0L)
3040 jjCheckNAddStates(22, 24);
3041 else if (curChar == 46)
3042 jjCheckNAddStates(25, 27);
3043 if ((0x3ff0c1800000000L & l) != 0L)
3044 {
3045 if (kind > 54)
3046 kind = 54;
3047 jjCheckNAddTwoStates(7, 8);
3048 }
3049 else if (curChar == 46)
3050 jjCheckNAddStates(28, 30);
3051 break;
3052 case 0:
3053 if ((0x3ff0c1800000000L & l) != 0L)
3054 {
3055 if (kind > 54)
3056 kind = 54;
3057 jjCheckNAddStates(31, 35);
3058 }
3059 else if (curChar == 46)
3060 jjCheckNAddStates(36, 38);
3061 break;
3062 case 1:
3063 if ((0x3ff081800000000L & l) == 0L)
3064 break;
3065 if (kind > 52)
3066 kind = 52;
3067 jjCheckNAddTwoStates(1, 2);
3068 break;
3069 case 2:
3070 if (curChar == 46)
3071 jjCheckNAdd(3);
3072 break;
3073 case 3:
3074 if ((0x3ff081800000000L & l) == 0L)
3075 break;
3076 if (kind > 52)
3077 kind = 52;
3078 jjCheckNAddTwoStates(2, 3);
3079 break;
3080 case 4:
3081 if (curChar == 46)
3082 jjCheckNAddStates(36, 38);
3083 break;
3084 case 6:
3085 if (curChar != 46)
3086 break;
3087 if (kind > 54)
3088 kind = 54;
3089 jjCheckNAddTwoStates(7, 8);
3090 break;
3091 case 7:
3092 if ((0x3ff0c1800000000L & l) == 0L)
3093 break;
3094 if (kind > 54)
3095 kind = 54;
3096 jjCheckNAddTwoStates(7, 8);
3097 break;
3098 case 8:
3099 if (curChar == 46)
3100 jjCheckNAddStates(25, 27);
3101 break;
3102 case 9:
3103 if ((0x3ff0c1800000000L & l) == 0L)
3104 break;
3105 if (kind > 54)
3106 kind = 54;
3107 jjCheckNAddTwoStates(9, 10);
3108 break;
3109 case 10:
3110 if (curChar == 46)
3111 jjCheckNAddStates(39, 41);
3112 break;
3113 case 11:
3114 if (curChar == 46)
3115 jjCheckNAdd(12);
3116 break;
3117 case 12:
3118 if (curChar != 46)
3119 break;
3120 if (kind > 54)
3121 kind = 54;
3122 jjCheckNAddTwoStates(9, 10);
3123 break;
3124 case 13:
3125 if (curChar == 46)
3126 jjCheckNAddStates(22, 24);
3127 break;
3128 case 14:
3129 if ((0x3ff0c1800000000L & l) != 0L)
3130 jjCheckNAddStates(22, 24);
3131 break;
3132 case 17:
3133 if (curChar == 46)
3134 jjCheckNAddStates(28, 30);
3135 break;
3136 case 18:
3137 if ((0x3ff0c1800000000L & l) != 0L)
3138 jjCheckNAddStates(42, 44);
3139 break;
3140 case 19:
3141 if (curChar == 46)
3142 jjCheckNAddStates(45, 47);
3143 break;
3144 case 20:
3145 if (curChar == 46)
3146 jjCheckNAdd(21);
3147 break;
3148 case 21:
3149 if (curChar == 46)
3150 jjCheckNAddStates(42, 44);
3151 break;
3152 case 22:
3153 if ((0x3ff0c1800000000L & l) == 0L)
3154 break;
3155 if (kind > 54)
3156 kind = 54;
3157 jjCheckNAddStates(31, 35);
3158 break;
3159 default : break;
3160 }
3161 } while(i != startsAt);
3162 }
3163 else if (curChar < 128)
3164 {
3165 long l = 1L << (curChar & 077);
3166 MatchLoop: do
3167 {
3168 switch(jjstateSet[--i])
3169 {
3170 case 23:
3171 if ((0x7fffffe87fffffeL & l) != 0L)
3172 jjCheckNAddStates(22, 24);
3173 else if (curChar == 91)
3174 jjstateSet[jjnewStateCnt++] = 15;
3175 if ((0x7fffffe87fffffeL & l) != 0L)
3176 {
3177 if (kind > 54)
3178 kind = 54;
3179 jjCheckNAddTwoStates(7, 8);
3180 }
3181 break;
3182 case 0:
3183 if ((0x7fffffe87fffffeL & l) != 0L)
3184 {
3185 if (kind > 54)
3186 kind = 54;
3187 jjCheckNAddStates(31, 35);
3188 }
3189 else if (curChar == 64)
3190 jjCheckNAdd(1);
3191 break;
3192 case 1:
3193 if ((0x7fffffe87fffffeL & l) == 0L)
3194 break;
3195 if (kind > 52)
3196 kind = 52;
3197 jjCheckNAddTwoStates(1, 2);
3198 break;
3199 case 3:
3200 if ((0x7fffffe87fffffeL & l) == 0L)
3201 break;
3202 if (kind > 52)
3203 kind = 52;
3204 jjCheckNAddTwoStates(2, 3);
3205 break;
3206 case 7:
3207 if ((0x7fffffe87fffffeL & l) == 0L)
3208 break;
3209 if (kind > 54)
3210 kind = 54;
3211 jjCheckNAddTwoStates(7, 8);
3212 break;
3213 case 9:
3214 if ((0x7fffffe87fffffeL & l) == 0L)
3215 break;
3216 if (kind > 54)
3217 kind = 54;
3218 jjAddStates(48, 49);
3219 break;
3220 case 14:
3221 if ((0x7fffffe87fffffeL & l) != 0L)
3222 jjCheckNAddStates(22, 24);
3223 break;
3224 case 15:
3225 if (curChar != 93)
3226 break;
3227 kind = 55;
3228 jjCheckNAdd(16);
3229 break;
3230 case 16:
3231 if (curChar == 91)
3232 jjstateSet[jjnewStateCnt++] = 15;
3233 break;
3234 case 18:
3235 if ((0x7fffffe87fffffeL & l) != 0L)
3236 jjCheckNAddStates(42, 44);
3237 break;
3238 case 22:
3239 if ((0x7fffffe87fffffeL & l) == 0L)
3240 break;
3241 if (kind > 54)
3242 kind = 54;
3243 jjCheckNAddStates(31, 35);
3244 break;
3245 default : break;
3246 }
3247 } while(i != startsAt);
3248 }
3249 else
3250 {
3251 int i2 = (curChar & 0xff) >> 6;
3252 long l2 = 1L << (curChar & 077);
3253 MatchLoop: do
3254 {
3255 switch(jjstateSet[--i])
3256 {
3257 default : break;
3258 }
3259 } while(i != startsAt);
3260 }
3261 if (kind != 0x7fffffff)
3262 {
3263 jjmatchedKind = kind;
3264 jjmatchedPos = curPos;
3265 kind = 0x7fffffff;
3266 }
3267 ++curPos;
3268 if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
3269 return curPos;
3270 try { curChar = input_stream.readChar(); }
3271 catch(java.io.IOException e) { return curPos; }
3272 }
3273}
3274private static final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
3275{
3276 switch (pos)
3277 {
3278 default :
3279 return -1;
3280 }
3281}
3282private static final int jjStartNfa_1(int pos, long active0, long active1)
3283{
3284 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
3285}
3286static private final int jjStartNfaWithStates_1(int pos, int kind, int state)
3287{
3288 jjmatchedKind = kind;
3289 jjmatchedPos = pos;
3290 try { curChar = input_stream.readChar(); }
3291 catch(java.io.IOException e) { return pos + 1; }
3292 return jjMoveNfa_1(state, pos + 1);
3293}
3294static private final int jjMoveStringLiteralDfa0_1()
3295{
3296 switch(curChar)
3297 {
3298 case 33:
3299 return jjStopAtPos(0, 80);
3300 case 44:
3301 return jjStopAtPos(0, 3);
3302 case 46:
3303 return jjStartNfaWithStates_1(0, 4, 5);
3304 default :
3305 return jjMoveNfa_1(0, 0);
3306 }
3307}
3308static private final int jjMoveNfa_1(int startState, int curPos)
3309{
3310 int[] nextStates;
3311 int startsAt = 0;
3312 jjnewStateCnt = 23;
3313 int i = 1;
3314 jjstateSet[0] = startState;
3315 int j, kind = 0x7fffffff;
3316 for (;;)
3317 {
3318 if (++jjround == 0x7fffffff)
3319 ReInitRounds();
3320 if (curChar < 64)
3321 {
3322 long l = 1L << curChar;
3323 MatchLoop: do
3324 {
3325 switch(jjstateSet[--i])
3326 {
3327 case 5:
3328 if (curChar == 46)
3329 jjCheckNAddStates(22, 24);
3330 if (curChar == 46)
3331 {
3332 if (kind > 76)
3333 kind = 76;
3334 jjCheckNAddTwoStates(7, 8);
3335 }
3336 if (curChar == 46)
3337 {
3338 if (kind > 7)
3339 kind = 7;
3340 }
3341 break;
3342 case 0:
3343 if ((0x3ff0c1800000000L & l) != 0L)
3344 {
3345 if (kind > 76)
3346 kind = 76;
3347 jjCheckNAddStates(31, 35);
3348 }
3349 else if (curChar == 46)
3350 jjCheckNAddStates(36, 38);
3351 break;
3352 case 1:
3353 if ((0x3ff0c1800000000L & l) == 0L)
3354 break;
3355 if (kind > 78)
3356 kind = 78;
3357 jjCheckNAddTwoStates(1, 2);
3358 break;
3359 case 2:
3360 if (curChar == 46)
3361 jjstateSet[jjnewStateCnt++] = 3;
3362 break;
3363 case 3:
3364 if (curChar != 46)
3365 break;
3366 if (kind > 78)
3367 kind = 78;
3368 jjCheckNAddTwoStates(1, 2);
3369 break;
3370 case 4:
3371 if (curChar == 46)
3372 jjCheckNAddStates(36, 38);
3373 break;
3374 case 6:
3375 if (curChar != 46)
3376 break;
3377 if (kind > 76)
3378 kind = 76;
3379 jjCheckNAddTwoStates(7, 8);
3380 break;
3381 case 7:
3382 if ((0x3ff0c1800000000L & l) == 0L)
3383 break;
3384 if (kind > 76)
3385 kind = 76;
3386 jjCheckNAddTwoStates(7, 8);
3387 break;
3388 case 8:
3389 if (curChar == 46)
3390 jjCheckNAddStates(25, 27);
3391 break;
3392 case 9:
3393 if ((0x3ff0c1800000000L & l) == 0L)
3394 break;
3395 if (kind > 76)
3396 kind = 76;
3397 jjCheckNAddTwoStates(9, 10);
3398 break;
3399 case 10:
3400 if (curChar == 46)
3401 jjCheckNAddStates(39, 41);
3402 break;
3403 case 11:
3404 if (curChar == 46)
3405 jjCheckNAdd(12);
3406 break;
3407 case 12:
3408 if (curChar != 46)
3409 break;
3410 if (kind > 76)
3411 kind = 76;
3412 jjCheckNAddTwoStates(9, 10);
3413 break;
3414 case 13:
3415 if (curChar == 46)
3416 jjCheckNAddStates(22, 24);
3417 break;
3418 case 14:
3419 if ((0x3ff0c1800000000L & l) != 0L)
3420 jjCheckNAddStates(22, 24);
3421 break;
3422 case 17:
3423 if (curChar == 46)
3424 jjCheckNAddStates(28, 30);
3425 break;
3426 case 18:
3427 if ((0x3ff0c1800000000L & l) != 0L)
3428 jjCheckNAddStates(42, 44);
3429 break;
3430 case 19:
3431 if (curChar == 46)
3432 jjCheckNAddStates(45, 47);
3433 break;
3434 case 20:
3435 if (curChar == 46)
3436 jjCheckNAdd(21);
3437 break;
3438 case 21:
3439 if (curChar == 46)
3440 jjCheckNAddStates(42, 44);
3441 break;
3442 case 22:
3443 if ((0x3ff0c1800000000L & l) == 0L)
3444 break;
3445 if (kind > 76)
3446 kind = 76;
3447 jjCheckNAddStates(31, 35);
3448 break;
3449 default : break;
3450 }
3451 } while(i != startsAt);
3452 }
3453 else if (curChar < 128)
3454 {
3455 long l = 1L << (curChar & 077);
3456 MatchLoop: do
3457 {
3458 switch(jjstateSet[--i])
3459 {
3460 case 0:
3461 if ((0x7fffffe87fffffeL & l) != 0L)
3462 {
3463 if (kind > 76)
3464 kind = 76;
3465 jjCheckNAddStates(31, 35);
3466 }
3467 else if (curChar == 64)
3468 jjCheckNAddTwoStates(1, 2);
3469 break;
3470 case 1:
3471 if ((0x7fffffe87fffffeL & l) == 0L)
3472 break;
3473 if (kind > 78)
3474 kind = 78;
3475 jjCheckNAddTwoStates(1, 2);
3476 break;
3477 case 7:
3478 if ((0x7fffffe87fffffeL & l) == 0L)
3479 break;
3480 if (kind > 76)
3481 kind = 76;
3482 jjCheckNAddTwoStates(7, 8);
3483 break;
3484 case 9:
3485 if ((0x7fffffe87fffffeL & l) == 0L)
3486 break;
3487 if (kind > 76)
3488 kind = 76;
3489 jjAddStates(48, 49);
3490 break;
3491 case 14:
3492 if ((0x7fffffe87fffffeL & l) != 0L)
3493 jjCheckNAddStates(22, 24);
3494 break;
3495 case 15:
3496 if (curChar != 93)
3497 break;
3498 kind = 77;
3499 jjCheckNAdd(16);
3500 break;
3501 case 16:
3502 if (curChar == 91)
3503 jjstateSet[jjnewStateCnt++] = 15;
3504 break;
3505 case 18:
3506 if ((0x7fffffe87fffffeL & l) != 0L)
3507 jjCheckNAddStates(42, 44);
3508 break;
3509 case 22:
3510 if ((0x7fffffe87fffffeL & l) == 0L)
3511 break;
3512 if (kind > 76)
3513 kind = 76;
3514 jjCheckNAddStates(31, 35);
3515 break;
3516 default : break;
3517 }
3518 } while(i != startsAt);
3519 }
3520 else
3521 {
3522 int i2 = (curChar & 0xff) >> 6;
3523 long l2 = 1L << (curChar & 077);
3524 MatchLoop: do
3525 {
3526 switch(jjstateSet[--i])
3527 {
3528 default : break;
3529 }
3530 } while(i != startsAt);
3531 }
3532 if (kind != 0x7fffffff)
3533 {
3534 jjmatchedKind = kind;
3535 jjmatchedPos = curPos;
3536 kind = 0x7fffffff;
3537 }
3538 ++curPos;
3539 if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
3540 return curPos;
3541 try { curChar = input_stream.readChar(); }
3542 catch(java.io.IOException e) { return curPos; }
3543 }
3544}
3545static final int[] jjnextStates = {
3546 19, 20, 21, 3, 4, 6, 7, 10, 6, 7, 10, 7, 8, 10, 6, 7,
3547 9, 7, 9, 10, 7, 8, 14, 16, 17, 6, 9, 11, 13, 18, 20, 7,
3548 14, 16, 17, 8, 5, 6, 13, 9, 11, 12, 18, 16, 19, 18, 20, 21,
3549 9, 10,
3550};
3551public static final String [] jjstrLiteralImages = {
3552"", null, null, "\54", "\56", null, null, null, null, null, "\41",
3553"\145\170\145\143\165\164\151\157\156\50", "\143\141\154\154\50", "\163\145\164\50", "\147\145\164\50",
3554"\150\141\156\144\154\145\162\50", "\167\151\164\150\151\156\50", "\167\151\164\150\151\156\143\157\144\145\50",
3555"\163\164\141\164\151\143\151\156\151\164\151\141\154\151\172\141\164\151\157\156\50", "\143\146\154\157\167\50", "\143\146\154\157\167\142\145\154\157\167\50",
3556"\141\162\147\163\50", "\164\141\162\147\145\164\50", "\164\150\151\163\50", "\151\146\50",
3557"\150\141\163\155\145\164\150\157\144\50", "\150\141\163\146\151\145\154\144\50", null, null,
3558"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
3559"\163\164\141\164\151\143", "\141\142\163\164\162\141\143\164", "\146\151\156\141\154", "\41", null, null,
3560null, null, null, "\51", "\160\165\142\154\151\143",
3561"\160\162\157\164\145\143\164\145\144", "\160\162\151\166\141\164\145", "\163\164\141\164\151\143",
3562"\141\142\163\164\162\141\143\164", "\146\151\156\141\154", "\156\141\164\151\166\145",
3563"\163\171\156\143\150\162\157\156\151\172\145\144",
3564"\163\164\141\164\151\143\151\156\151\164\151\141\154\151\172\141\164\151\157\156", "\41", null, null, null, null, null, "\50", "\51", null,
3565"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
3566"\163\164\141\164\151\143", "\141\142\163\164\162\141\143\164", "\146\151\156\141\154",
3567"\164\162\141\156\163\151\145\156\164", "\41", null, null, null, null, null, null, "\51", null, null, null, null, null,
3568"\41", null, null, null, null, "\51", "\50", "\51", };
3569public static final String [] lexStateNames = {
3570 "IN_ARGS",
3571 "PARAMETERS",
3572 "FIELD",
3573 "METHOD",
3574 "CLASS",
3575 "DEFAULT",
3576};
3577public static final int[] jjnewLexState = {
3578 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 2, 2, 4, 4, 3, 4, -1, -1, 0, 4, 4, -1,
3579 3, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1,
3580 -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5,
3581 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1,
3582};
3583static final long[] jjtoToken = {
3584 0xf6dffe3fffffff99L, 0xed74dfL,
3585};
3586static final long[] jjtoSkip = {
3587 0x6L, 0x0L,
3588};
3589static protected SimpleCharStream input_stream;
3590static private final int[] jjrounds = new int[23];
3591static private final int[] jjstateSet = new int[46];
3592static protected char curChar;
3593public ExpressionParserTokenManager(SimpleCharStream stream)
3594{
3595 if (input_stream != null)
3596 throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
3597 input_stream = stream;
3598}
3599public ExpressionParserTokenManager(SimpleCharStream stream, int lexState)
3600{
3601 this(stream);
3602 SwitchTo(lexState);
3603}
3604static public void ReInit(SimpleCharStream stream)
3605{
3606 jjmatchedPos = jjnewStateCnt = 0;
3607 curLexState = defaultLexState;
3608 input_stream = stream;
3609 ReInitRounds();
3610}
3611static private final void ReInitRounds()
3612{
3613 int i;
3614 jjround = 0x80000001;
3615 for (i = 23; i-- > 0;)
3616 jjrounds[i] = 0x80000000;
3617}
3618static public void ReInit(SimpleCharStream stream, int lexState)
3619{
3620 ReInit(stream);
3621 SwitchTo(lexState);
3622}
3623static public void SwitchTo(int lexState)
3624{
3625 if (lexState >= 6 || lexState < 0)
3626 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3627 else
3628 curLexState = lexState;
3629}
3630
3631static protected Token jjFillToken()
3632{
3633 Token t = Token.newToken(jjmatchedKind);
3634 t.kind = jjmatchedKind;
3635 String im = jjstrLiteralImages[jjmatchedKind];
3636 t.image = (im == null) ? input_stream.GetImage() : im;
3637 t.beginLine = input_stream.getBeginLine();
3638 t.beginColumn = input_stream.getBeginColumn();
3639 t.endLine = input_stream.getEndLine();
3640 t.endColumn = input_stream.getEndColumn();
3641 return t;
3642}
3643
3644static int curLexState = 5;
3645static int defaultLexState = 5;
3646static int jjnewStateCnt;
3647static int jjround;
3648static int jjmatchedPos;
3649static int jjmatchedKind;
3650
3651public static Token getNextToken()
3652{
3653 int kind;
3654 Token specialToken = null;
3655 Token matchedToken;
3656 int curPos = 0;
3657
3658 EOFLoop :
3659 for (;;)
3660 {
3661 try
3662 {
3663 curChar = input_stream.BeginToken();
3664 }
3665 catch(java.io.IOException e)
3666 {
3667 jjmatchedKind = 0;
3668 matchedToken = jjFillToken();
3669 return matchedToken;
3670 }
3671
3672 switch(curLexState)
3673 {
3674 case 0:
3675 try { input_stream.backup(0);
3676 while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3677 curChar = input_stream.BeginToken();
3678 }
3679 catch (java.io.IOException e1) { continue EOFLoop; }
3680 jjmatchedKind = 0x7fffffff;
3681 jjmatchedPos = 0;
3682 curPos = jjMoveStringLiteralDfa0_0();
3683 break;
3684 case 1:
3685 try { input_stream.backup(0);
3686 while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3687 curChar = input_stream.BeginToken();
3688 }
3689 catch (java.io.IOException e1) { continue EOFLoop; }
3690 jjmatchedKind = 0x7fffffff;
3691 jjmatchedPos = 0;
3692 curPos = jjMoveStringLiteralDfa0_1();
3693 break;
3694 case 2:
3695 try { input_stream.backup(0);
3696 while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3697 curChar = input_stream.BeginToken();
3698 }
3699 catch (java.io.IOException e1) { continue EOFLoop; }
3700 jjmatchedKind = 0x7fffffff;
3701 jjmatchedPos = 0;
3702 curPos = jjMoveStringLiteralDfa0_2();
3703 break;
3704 case 3:
3705 try { input_stream.backup(0);
3706 while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3707 curChar = input_stream.BeginToken();
3708 }
3709 catch (java.io.IOException e1) { continue EOFLoop; }
3710 jjmatchedKind = 0x7fffffff;
3711 jjmatchedPos = 0;
3712 curPos = jjMoveStringLiteralDfa0_3();
3713 break;
3714 case 4:
3715 try { input_stream.backup(0);
3716 while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3717 curChar = input_stream.BeginToken();
3718 }
3719 catch (java.io.IOException e1) { continue EOFLoop; }
3720 jjmatchedKind = 0x7fffffff;
3721 jjmatchedPos = 0;
3722 curPos = jjMoveStringLiteralDfa0_4();
3723 break;
3724 case 5:
3725 try { input_stream.backup(0);
3726 while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3727 curChar = input_stream.BeginToken();
3728 }
3729 catch (java.io.IOException e1) { continue EOFLoop; }
3730 jjmatchedKind = 0x7fffffff;
3731 jjmatchedPos = 0;
3732 curPos = jjMoveStringLiteralDfa0_5();
3733 break;
3734 }
3735 if (jjmatchedKind != 0x7fffffff)
3736 {
3737 if (jjmatchedPos + 1 < curPos)
3738 input_stream.backup(curPos - jjmatchedPos - 1);
3739 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3740 {
3741 matchedToken = jjFillToken();
3742 if (jjnewLexState[jjmatchedKind] != -1)
3743 curLexState = jjnewLexState[jjmatchedKind];
3744 return matchedToken;
3745 }
3746 else
3747 {
3748 if (jjnewLexState[jjmatchedKind] != -1)
3749 curLexState = jjnewLexState[jjmatchedKind];
3750 continue EOFLoop;
3751 }
3752 }
3753 int error_line = input_stream.getEndLine();
3754 int error_column = input_stream.getEndColumn();
3755 String error_after = null;
3756 boolean EOFSeen = false;
3757 try { input_stream.readChar(); input_stream.backup(1); }
3758 catch (java.io.IOException e1) {
3759 EOFSeen = true;
3760 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3761 if (curChar == '\n' || curChar == '\r') {
3762 error_line++;
3763 error_column = 0;
3764 }
3765 else
3766 error_column++;
3767 }
3768 if (!EOFSeen) {
3769 input_stream.backup(1);
3770 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3771 }
3772 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3773 }
3774}
3775
3776}
3777 |
Popular Tags |
Java API By Example, From Geeks To Geeks.