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