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