|
1
2 package freemarker.core;
3 import freemarker.template.*;
4 import freemarker.template.utility.StringUtil;
5 import freemarker.template.utility.DeepUnwrap;
6 import java.io.*;
7 import java.util.*;
8
9 class FMParserTokenManager implements FMParserConstants
10 {
11
20 String  noparseTag;
21
22
30 private int hashLiteralNesting;
31 private int parenthesisNesting;
32 private boolean inFTLHeader;
33 boolean strictEscapeSyntax, onlyTextOutput;
34 String templateName;
35
36
39 private void strictSyntaxCheck(Token tok, int newLexState) {
40 if (onlyTextOutput || (strictEscapeSyntax
41 && !tok.image.startsWith("<#")
42 && !tok.image.startsWith("</#")))
43 {
44 tok.kind = PRINTABLE_CHARS;
45 }
46 else {
47 SwitchTo(newLexState);
48 }
49 }
50
51 private void eatNewline() {
52 int charsRead = 0;
53 try {
54 while (true) {
55 char c = input_stream.readChar();
56 ++charsRead;
57 if (!Character.isWhitespace(c)) {
58 input_stream.backup(charsRead);
59 } else if (c=='\r') {
60 char next = input_stream.readChar();
61 ++charsRead;
62 if (next != '\n') {
63 input_stream.backup(1);
64 }
65 return;
66 } else if (c=='\n') {
67 return;
68 }
69 }
70 } catch (IOException ioe) {
71 input_stream.backup(charsRead);
72 }
73 }
74 public java.io.PrintStream debugStream = System.out;
75 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
76 private final int jjStopStringLiteralDfa_6(int pos, long active0, long active1)
77 {
78 switch (pos)
79 {
80 case 0:
81 if ((active1 & 0x4000000000000000L) != 0L)
82 {
83 jjmatchedKind = 129;
84 return -1;
85 }
86 return -1;
87 case 1:
88 if ((active1 & 0x4000000000000000L) != 0L)
89 {
90 if (jjmatchedPos == 0)
91 {
92 jjmatchedKind = 129;
93 jjmatchedPos = 0;
94 }
95 return -1;
96 }
97 return -1;
98 default :
99 return -1;
100 }
101 }
102 private final int jjStartNfa_6(int pos, long active0, long active1)
103 {
104 return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1);
105 }
106 private final int jjStopAtPos(int pos, int kind)
107 {
108 jjmatchedKind = kind;
109 jjmatchedPos = pos;
110 return pos + 1;
111 }
112 private final int jjStartNfaWithStates_6(int pos, int kind, int state)
113 {
114 jjmatchedKind = kind;
115 jjmatchedPos = pos;
116 try { curChar = input_stream.readChar(); }
117 catch(java.io.IOException e) { return pos + 1; }
118 return jjMoveNfa_6(state, pos + 1);
119 }
120 private final int jjMoveStringLiteralDfa0_6()
121 {
122 switch(curChar)
123 {
124 case 45:
125 return jjMoveStringLiteralDfa1_6(0x4000000000000000L);
126 default :
127 return jjMoveNfa_6(5, 0);
128 }
129 }
130 private final int jjMoveStringLiteralDfa1_6(long active1)
131 {
132 try { curChar = input_stream.readChar(); }
133 catch(java.io.IOException e) {
134 jjStopStringLiteralDfa_6(0, 0L, active1);
135 return 1;
136 }
137 switch(curChar)
138 {
139 case 45:
140 return jjMoveStringLiteralDfa2_6(active1, 0x4000000000000000L);
141 default :
142 break;
143 }
144 return jjStartNfa_6(0, 0L, active1);
145 }
146 private final int jjMoveStringLiteralDfa2_6(long old1, long active1)
147 {
148 if (((active1 &= old1)) == 0L)
149 return jjStartNfa_6(0, 0L, old1);
150 try { curChar = input_stream.readChar(); }
151 catch(java.io.IOException e) {
152 jjStopStringLiteralDfa_6(1, 0L, active1);
153 return 2;
154 }
155 switch(curChar)
156 {
157 case 62:
158 if ((active1 & 0x4000000000000000L) != 0L)
159 return jjStopAtPos(2, 126);
160 break;
161 default :
162 break;
163 }
164 return jjStartNfa_6(1, 0L, active1);
165 }
166 private final void jjCheckNAdd(int state)
167 {
168 if (jjrounds[state] != jjround)
169 {
170 jjstateSet[jjnewStateCnt++] = state;
171 jjrounds[state] = jjround;
172 }
173 }
174 private final void jjAddStates(int start, int end)
175 {
176 do {
177 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
178 } while (start++ != end);
179 }
180 private final void jjCheckNAddTwoStates(int state1, int state2)
181 {
182 jjCheckNAdd(state1);
183 jjCheckNAdd(state2);
184 }
185 private final void jjCheckNAddStates(int start, int end)
186 {
187 do {
188 jjCheckNAdd(jjnextStates[start]);
189 } while (start++ != end);
190 }
191 private final void jjCheckNAddStates(int start)
192 {
193 jjCheckNAdd(jjnextStates[start]);
194 jjCheckNAdd(jjnextStates[start + 1]);
195 }
196 static final long[] jjbitVec0 = {
197 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
198 };
199 static final long[] jjbitVec2 = {
200 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
201 };
202 private final int jjMoveNfa_6(int startState, int curPos)
203 {
204 int[] nextStates;
205 int startsAt = 0;
206 jjnewStateCnt = 8;
207 int i = 1;
208 jjstateSet[0] = startState;
209 int j, kind = 0x7fffffff;
210 for (;;)
211 {
212 if (++jjround == 0x7fffffff)
213 ReInitRounds();
214 if (curChar < 64)
215 {
216 long l = 1L << curChar;
217 MatchLoop: do
218 {
219 switch(jjstateSet[--i])
220 {
221 case 5:
222 if ((0xefffdfffffffffffL & l) != 0L)
223 {
224 if (kind > 128)
225 kind = 128;
226 jjCheckNAdd(6);
227 }
228 else if ((0x1000200000000000L & l) != 0L)
229 {
230 if (kind > 129)
231 kind = 129;
232 }
233 if (curChar == 60)
234 jjstateSet[jjnewStateCnt++] = 0;
235 break;
236 case 0:
237 if (curChar == 47)
238 jjCheckNAddTwoStates(1, 2);
239 break;
240 case 1:
241 if (curChar == 35)
242 jjCheckNAdd(2);
243 break;
244 case 3:
245 if ((0x100002600L & l) != 0L)
246 jjAddStates(0, 1);
247 break;
248 case 4:
249 if (curChar == 62 && kind > 127)
250 kind = 127;
251 break;
252 case 6:
253 if ((0xefffdfffffffffffL & l) == 0L)
254 break;
255 if (kind > 128)
256 kind = 128;
257 jjCheckNAdd(6);
258 break;
259 case 7:
260 if ((0x1000200000000000L & l) != 0L && kind > 129)
261 kind = 129;
262 break;
263 default : break;
264 }
265 } while(i != startsAt);
266 }
267 else if (curChar < 128)
268 {
269 long l = 1L << (curChar & 077);
270 MatchLoop: do
271 {
272 switch(jjstateSet[--i])
273 {
274 case 5:
275 case 6:
276 if (kind > 128)
277 kind = 128;
278 jjCheckNAdd(6);
279 break;
280 case 2:
281 if ((0x7fffffe07fffffeL & l) != 0L)
282 jjAddStates(2, 4);
283 break;
284 default : break;
285 }
286 } while(i != startsAt);
287 }
288 else
289 {
290 int hiByte = (int)(curChar >> 8);
291 int i1 = hiByte >> 6;
292 long l1 = 1L << (hiByte & 077);
293 int i2 = (curChar & 0xff) >> 6;
294 long l2 = 1L << (curChar & 077);
295 MatchLoop: do
296 {
297 switch(jjstateSet[--i])
298 {
299 case 5:
300 case 6:
301 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
302 break;
303 if (kind > 128)
304 kind = 128;
305 jjCheckNAdd(6);
306 break;
307 default : break;
308 }
309 } while(i != startsAt);
310 }
311 if (kind != 0x7fffffff)
312 {
313 jjmatchedKind = kind;
314 jjmatchedPos = curPos;
315 kind = 0x7fffffff;
316 }
317 ++curPos;
318 if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
319 return curPos;
320 try { curChar = input_stream.readChar(); }
321 catch(java.io.IOException e) { return curPos; }
322 }
323 }
324 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
325 {
326 switch (pos)
327 {
328 case 0:
329 if ((active1 & 0x180L) != 0L)
330 {
331 jjmatchedKind = 70;
332 return -1;
333 }
334 return -1;
335 default :
336 return -1;
337 }
338 }
339 private final int jjStartNfa_1(int pos, long active0, long active1)
340 {
341 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
342 }
343 private final int jjStartNfaWithStates_1(int pos, int kind, int state)
344 {
345 jjmatchedKind = kind;
346 jjmatchedPos = pos;
347 try { curChar = input_stream.readChar(); }
348 catch(java.io.IOException e) { return pos + 1; }
349 return jjMoveNfa_1(state, pos + 1);
350 }
351 private final int jjMoveStringLiteralDfa0_1()
352 {
353 switch(curChar)
354 {
355 case 35:
356 return jjMoveStringLiteralDfa1_1(0x100L);
357 case 36:
358 return jjMoveStringLiteralDfa1_1(0x80L);
359 default :
360 return jjMoveNfa_1(2, 0);
361 }
362 }
363 private final int jjMoveStringLiteralDfa1_1(long active1)
364 {
365 try { curChar = input_stream.readChar(); }
366 catch(java.io.IOException e) {
367 jjStopStringLiteralDfa_1(0, 0L, active1);
368 return 1;
369 }
370 switch(curChar)
371 {
372 case 123:
373 if ((active1 & 0x80L) != 0L)
374 return jjStopAtPos(1, 71);
375 else if ((active1 & 0x100L) != 0L)
376 return jjStopAtPos(1, 72);
377 break;
378 default :
379 break;
380 }
381 return jjStartNfa_1(0, 0L, active1);
382 }
383 private final int jjMoveNfa_1(int startState, int curPos)
384 {
385 int[] nextStates;
386 int startsAt = 0;
387 jjnewStateCnt = 6;
388 int i = 1;
389 jjstateSet[0] = startState;
390 int j, kind = 0x7fffffff;
391 for (;;)
392 {
393 if (++jjround == 0x7fffffff)
394 ReInitRounds();
395 if (curChar < 64)
396 {
397 long l = 1L << curChar;
398 MatchLoop: do
399 {
400 switch(jjstateSet[--i])
401 {
402 case 2:
403 if ((0xefffffe6ffffd9ffL & l) != 0L)
404 {
405 if (kind > 69)
406 kind = 69;
407 jjCheckNAdd(1);
408 }
409 else if ((0x100002600L & l) != 0L)
410 {
411 if (kind > 68)
412 kind = 68;
413 jjCheckNAdd(0);
414 }
415 else if ((0x1800000000L & l) != 0L)
416 {
417 if (kind > 70)
418 kind = 70;
419 }
420 else if (curChar == 60)
421 {
422 if (kind > 70)
423 kind = 70;
424 jjstateSet[jjnewStateCnt++] = 4;
425 }
426 break;
427 case 0:
428 if ((0x100002600L & l) == 0L)
429 break;
430 if (kind > 68)
431 kind = 68;
432 jjCheckNAdd(0);
433 break;
434 case 1:
435 if ((0xefffffe6ffffd9ffL & l) == 0L)
436 break;
437 kind = 69;
438 jjCheckNAdd(1);
439 break;
440 case 3:
441 if (curChar != 60)
442 break;
443 kind = 70;
444 jjstateSet[jjnewStateCnt++] = 4;
445 break;
446 case 5:
447 if ((0x100002600L & l) == 0L)
448 break;
449 if (kind > 70)
450 kind = 70;
451 jjstateSet[jjnewStateCnt++] = 5;
452 break;
453 default : break;
454 }
455 } while(i != startsAt);
456 }
457 else if (curChar < 128)
458 {
459 long l = 1L << (curChar & 077);
460 MatchLoop: do
461 {
462 switch(jjstateSet[--i])
463 {
464 case 2:
465 if ((0xffffffff7fffffffL & l) != 0L)
466 {
467 if (kind > 69)
468 kind = 69;
469 jjCheckNAdd(1);
470 }
471 else if (curChar == 95)
472 {
473 if (kind > 70)
474 kind = 70;
475 }
476 break;
477 case 1:
478 if ((0xffffffff7fffffffL & l) == 0L)
479 break;
480 if (kind > 69)
481 kind = 69;
482 jjCheckNAdd(1);
483 break;
484 case 4:
485 if (curChar == 64)
486 jjstateSet[jjnewStateCnt++] = 5;
487 break;
488 default : break;
489 }
490 } while(i != startsAt);
491 }
492 else
493 {
494 int hiByte = (int)(curChar >> 8);
495 int i1 = hiByte >> 6;
496 long l1 = 1L << (hiByte & 077);
497 int i2 = (curChar & 0xff) >> 6;
498 long l2 = 1L << (curChar & 077);
499 MatchLoop: do
500 {
501 switch(jjstateSet[--i])
502 {
503 case 2:
504 case 1:
505 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
506 break;
507 if (kind > 69)
508 kind = 69;
509 jjCheckNAdd(1);
510 break;
511 default : break;
512 }
513 } while(i != startsAt);
514 }
515 if (kind != 0x7fffffff)
516 {
517 jjmatchedKind = kind;
518 jjmatchedPos = curPos;
519 kind = 0x7fffffff;
520 }
521 ++curPos;
522 if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
523 return curPos;
524 try { curChar = input_stream.readChar(); }
525 catch(java.io.IOException e) { return curPos; }
526 }
527 }
528 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
529 {
530 switch (pos)
531 {
532 case 0:
533 if ((active1 & 0x180L) != 0L)
534 {
535 jjmatchedKind = 70;
536 return -1;
537 }
538 if ((active0 & 0x8000000020000000L) != 0L)
539 {
540 jjmatchedKind = 70;
541 return 4;
542 }
543 return -1;
544 case 1:
545 if ((active1 & 0x180L) != 0L)
546 {
547 if (jjmatchedPos == 0)
548 {
549 jjmatchedKind = 70;
550 jjmatchedPos = 0;
551 }
552 return -1;
553 }
554 if ((active0 & 0x20000000L) != 0L)
555 {
556 if (jjmatchedPos == 0)
557 {
558 jjmatchedKind = 70;
559 jjmatchedPos = 0;
560 }
561 return 518;
562 }
563 if ((active0 & 0x8000000000000000L) != 0L)
564 return 350;
565 return -1;
566 case 2:
567 if ((active0 & 0x20000000L) != 0L)
568 {
569 if (jjmatchedPos == 0)
570 {
571 jjmatchedKind = 70;
572 jjmatchedPos = 0;
573 }
574 return -1;
575 }
576 return -1;
577 default :
578 return -1;
579 }
580 }
581 private final int jjStartNfa_0(int pos, long active0, long active1)
582 {
583 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
584 }
585 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
586 {
587 jjmatchedKind = kind;
588 jjmatchedPos = pos;
589 try { curChar = input_stream.readChar(); }
590 catch(java.io.IOException e) { return pos + 1; }
591 return jjMoveNfa_0(state, pos + 1);
592 }
593 private final int jjMoveStringLiteralDfa0_0()
594 {
595 switch(curChar)
596 {
597 case 35:
598 return jjMoveStringLiteralDfa1_0(0x0L, 0x100L);
599 case 36:
600 return jjMoveStringLiteralDfa1_0(0x0L, 0x80L);
601 case 60:
602 return jjMoveStringLiteralDfa1_0(0x8000000020000000L, 0x0L);
603 default :
604 return jjMoveNfa_0(2, 0);
605 }
606 }
607 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
608 {
609 try { curChar = input_stream.readChar(); }
610 catch(java.io.IOException e) {
611 jjStopStringLiteralDfa_0(0, active0, active1);
612 return 1;
613 }
614 switch(curChar)
615 {
616 case 35:
617 return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
618 case 64:
619 if ((active0 & 0x8000000000000000L) != 0L)
620 return jjStartNfaWithStates_0(1, 63, 350);
621 break;
622 case 123:
623 if ((active1 & 0x80L) != 0L)
624 return jjStopAtPos(1, 71);
625 else if ((active1 & 0x100L) != 0L)
626 return jjStopAtPos(1, 72);
627 break;
628 default :
629 break;
630 }
631 return jjStartNfa_0(0, active0, active1);
632 }
633 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
634 {
635 if (((active0 &= old0) | (active1 &= old1)) == 0L)
636 return jjStartNfa_0(0, old0, old1);
637 try { curChar = input_stream.readChar(); }
638 catch(java.io.IOException e) {
639 jjStopStringLiteralDfa_0(1, active0, 0L);
640 return 2;
641 }
642 switch(curChar)
643 {
644 case 45:
645 return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
646 default :
647 break;
648 }
649 return jjStartNfa_0(1, active0, 0L);
650 }
651 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
652 {
653 if (((active0 &= old0)) == 0L)
654 return jjStartNfa_0(1, old0, 0L);
655 try { curChar = input_stream.readChar(); }
656 catch(java.io.IOException e) {
657 jjStopStringLiteralDfa_0(2, active0, 0L);
658 return 3;
659 }
660 switch(curChar)
661 {
662 case 45:
663 if ((active0 & 0x20000000L) != 0L)
664 return jjStopAtPos(3, 29);
665 break;
666 default :
667 break;
668 }
669 return jjStartNfa_0(2, active0, 0L);
670 }
671 static final long[] jjbitVec3 = {
672 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
673 };
674 static final long[] jjbitVec4 = {
675 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
676 };
677 static final long[] jjbitVec5 = {
678 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
679 };
680 static final long[] jjbitVec6 = {
681 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
682 };
683 static final long[] jjbitVec7 = {
684 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
685 };
686 static final long[] jjbitVec8 = {
687 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
688 };
689 private final int jjMoveNfa_0(int startState, int curPos)
690 {
691 int[] nextStates;
692 int startsAt = 0;
693 jjnewStateCnt = 526;
694 int i = 1;
695 jjstateSet[0] = startState;
696 int j, kind = 0x7fffffff;
697 for (;;)
698 {
699 if (++jjround == 0x7fffffff)
700 ReInitRounds();
701 if (curChar < 64)
702 {
703 long l = 1L << curChar;
704 MatchLoop: do
705 {
706 switch(jjstateSet[--i])
707 {
708 case 4:
709 if (curChar == 35)
710 jjstateSet[jjnewStateCnt++] = 348;
711 else if (curChar == 47)
712 jjCheckNAdd(347);
713 if (curChar == 35)
714 jjstateSet[jjnewStateCnt++] = 524;
715 else if (curChar == 47)
716 jjstateSet[jjnewStateCnt++] = 506;
717 if (curChar == 35)
718 jjstateSet[jjnewStateCnt++] = 518;
719 else if (curChar == 47)
720 jjCheckNAddTwoStates(495, 505);
721 if (curChar == 35)
722 jjCheckNAdd(345);
723 else if (curChar == 47)
724 jjCheckNAddTwoStates(485, 493);
725 if (curChar == 35)
726 jjCheckNAdd(334);
727 else if (curChar == 47)
728 jjCheckNAddTwoStates(475, 483);
729 if (curChar == 35)
730 jjCheckNAdd(326);
731 else if (curChar == 47)
732 jjCheckNAddTwoStates(462, 473);
733 if (curChar == 35)
734 jjCheckNAdd(314);
735 else if (curChar == 47)
736 jjCheckNAddTwoStates(450, 460);
737 if (curChar == 35)
738 jjCheckNAdd(305);
739 else if (curChar == 47)
740 jjCheckNAddTwoStates(441, 448);
741 if (curChar == 35)
742 jjCheckNAdd(294);
743 else if (curChar == 47)
744 jjCheckNAddTwoStates(429, 439);
745 if (curChar == 35)
746 jjCheckNAdd(286);
747 else if (curChar == 47)
748 jjCheckNAddTwoStates(419, 427);
749 if (curChar == 35)
750 jjCheckNAdd(276);
751 else if (curChar == 47)
752 jjCheckNAddTwoStates(409, 417);
753 if (curChar == 35)
754 jjCheckNAdd(266);
755 else if (curChar == 47)
756 jjCheckNAddTwoStates(400, 407);
757 if (curChar == 35)
758 jjCheckNAdd(260);
759 else if (curChar == 47)
760 jjCheckNAddTwoStates(389, 398);
761 if (curChar == 35)
762 jjCheckNAdd(254);
763 else if (curChar == 47)
764 jjCheckNAddTwoStates(378, 387);
765 if (curChar == 35)
766 jjCheckNAdd(245);
767 else if (curChar == 47)
768 jjCheckNAddTwoStates(367, 376);
769 if (curChar == 35)
770 jjCheckNAdd(243);
771 else if (curChar == 47)
772 jjCheckNAddTwoStates(359, 365);
773 if (curChar == 35)
774 jjCheckNAdd(234);
775 else if (curChar == 47)
776 jjCheckNAddTwoStates(353, 357);
777 if (curChar == 35)
778 jjCheckNAdd(226);
779 if (curChar == 35)
780 jjCheckNAdd(216);
781 if (curChar == 35)
782 jjCheckNAdd(207);
783 if (curChar == 35)
784 jjCheckNAdd(199);
785 if (curChar == 35)
786 jjCheckNAdd(189);
787 if (curChar == 35)
788 jjCheckNAdd(179);
789 if (curChar == 35)
790 jjCheckNAdd(168);
791 if (curChar == 35)
792 jjCheckNAdd(159);
793 if (curChar == 35)
794 jjCheckNAdd(153);
795 if (curChar == 35)
796 jjCheckNAdd(145);
797 if (curChar == 35)
798 jjCheckNAdd(139);
799 if (curChar == 35)
800 jjCheckNAdd(132);
801 if (curChar == 35)
802 jjCheckNAdd(121);
803 if (curChar == 35)
804 jjCheckNAdd(114);
805 if (curChar == 35)
806 jjCheckNAdd(104);
807 if (curChar == 35)
808 jjCheckNAdd(96);
809 if (curChar == 35)
810 jjCheckNAdd(87);
811 if (curChar == 35)
812 jjCheckNAdd(80);
813 if (curChar == 35)
814 jjCheckNAdd(72);
815 if (curChar == 35)
816 jjCheckNAdd(64);
817 if (curChar == 35)
818 jjCheckNAdd(58);
819 if (curChar == 35)
820 jjCheckNAdd(50);
821 if (curChar == 35)
822 jjCheckNAdd(41);
823 if (curChar == 35)
824 jjCheckNAdd(35);
825 if (curChar == 35)
826 jjCheckNAdd(27);
827 if (curChar == 35)
828 jjCheckNAdd(23);
829 if (curChar == 35)
830 jjCheckNAdd(13);
831 break;
832 case 2:
833 if ((0xefffffe6ffffd9ffL & l) != 0L)
834 {
835 if (kind > 69)
836 kind = 69;
837 jjCheckNAdd(1);
838 }
839 else if ((0x100002600L & l) != 0L)
840 {
841 if (kind > 68)
842 kind = 68;
843 jjCheckNAdd(0);
844 }
845 else if ((0x1800000000L & l) != 0L)
846 {
847 if (kind > 70)
848 kind = 70;
849 }
850 else if (curChar == 60)
851 jjAddStates(5, 22);
852 if (curChar == 60)
853 {
854 if (kind > 70)
855 kind = 70;
856 jjCheckNAddStates(23, 107);
857 }
858 break;
859 case 0:
860 if ((0x100002600L & l) == 0L)
861 break;
862 if (kind > 68)
863 kind = 68;
864 jjCheckNAdd(0);
865 break;
866 case 1:
867 if ((0xefffffe6ffffd9ffL & l) == 0L)
868 break;
869 if (kind > 69)
870 kind = 69;
871 jjCheckNAdd(1);
872 break;
873 case 3:
874 if (curChar != 60)
875 break;
876 if (kind > 70)
877 kind = 70;
878 jjCheckNAddStates(23, 107);
879 break;
880 case 6:
881 if ((0x100002600L & l) != 0L)
882 jjAddStates(108, 109);
883 break;
884 case 7:
885 if (curChar == 62 && kind > 6)
886 kind = 6;
887 break;
888 case 14:
889 if (curChar == 35)
890 jjCheckNAdd(23);
891 break;
892 case 16:
893 if ((0x100002600L & l) != 0L)
894 jjAddStates(110, 111);
895 break;
896 case 17:
897 if (curChar == 62 && kind > 7)
898 kind = 7;
899 break;
900 case 24:
901 if (curChar == 35)
902 jjCheckNAdd(27);
903 break;
904 case 26:
905 if ((0x100002600L & l) != 0L && kind > 8)
906 kind = 8;
907 break;
908 case 28:
909 if (curChar == 35)
910 jjCheckNAdd(35);
911 break;
912 case 30:
913 if ((0x100002600L & l) != 0L && kind > 9)
914 kind = 9;
915 break;
916 case 36:
917 if (curChar == 35)
918 jjCheckNAdd(41);
919 break;
920 case 38:
921 if ((0x100002600L & l) != 0L && kind > 10)
922 kind = 10;
923 break;
924 case 42:
925 if (curChar == 35)
926 jjCheckNAdd(50);
927 break;
928 case 44:
929 if ((0x100002600L & l) != 0L && kind > 11)
930 kind = 11;
931 break;
932 case 51:
933 if (curChar == 35)
934 jjCheckNAdd(58);
935 break;
936 case 53:
937 if ((0x100002600L & l) != 0L && kind > 12)
938 kind = 12;
939 break;
940 case 59:
941 if (curChar == 35)
942 jjCheckNAdd(64);
943 break;
944 case 61:
945 if ((0x100002600L & l) != 0L && kind > 13)
946 kind = 13;
947 break;
948 case 65:
949 if (curChar == 35)
950 jjCheckNAdd(72);
951 break;
952 case 67:
953 if ((0x100002600L & l) != 0L && kind > 14)
954 kind = 14;
955 break;
956 case 73:
957 if (curChar == 35)
958 jjCheckNAdd(80);
959 break;
960 case 75:
961 if ((0x100002600L & l) != 0L && kind > 15)
962 kind = 15;
963 break;
964 case 81:
965 if (curChar == 35)
966 jjCheckNAdd(87);
967 break;
968 case 83:
969 if ((0x100002600L & l) != 0L && kind > 16)
970 kind = 16;
971 break;
972 case 88:
973 if (curChar == 35)
974 jjCheckNAdd(96);
975 break;
976 case 90:
977 if ((0x100002600L & l) != 0L && kind > 17)
978 kind = 17;
979 break;
980 case 97:
981 if (curChar == 35)
982 jjCheckNAdd(104);
983 break;
984 case 99:
985 if ((0x100002600L & l) != 0L && kind > 18)
986 kind = 18;
987 break;
988 case 105:
989 if (curChar == 35)
990 jjCheckNAdd(114);
991 break;
992 case 107:
993 if ((0x100002600L & l) != 0L && kind > 19)
994 kind = 19;
995 break;
996 case 115:
997 if (curChar == 35)
998 jjCheckNAdd(121);
999 break;
1000 case 117:
1001 if ((0x100002600L & l) != 0L && kind > 20)
1002 kind = 20;
1003 break;
1004 case 122:
1005 if (curChar == 35)
1006 jjCheckNAdd(132);
1007 break;
1008 case 124:
1009 if ((0x100002600L & l) != 0L && kind > 21)
1010 kind = 21;
1011 break;
1012 case 133:
1013 if (curChar == 35)
1014 jjCheckNAdd(139);
1015 break;
1016 case 135:
1017 if ((0x100002600L & l) != 0L && kind > 22)
1018 kind = 22;
1019 break;
1020 case 140:
1021 if (curChar == 35)
1022 jjCheckNAdd(145);
1023 break;
1024 case 142:
1025 if ((0x100002600L & l) != 0L && kind > 23)
1026 kind = 23;
1027 break;
1028 case 146:
1029 if (curChar == 35)
1030 jjCheckNAdd(153);
1031 break;
1032 case 148:
1033 if ((0x100002600L & l) != 0L && kind > 24)
1034 kind = 24;
1035 break;
1036 case 154:
1037 if (curChar == 35)
1038 jjCheckNAdd(159);
1039 break;
1040 case 156:
1041 if ((0x100002600L & l) != 0L && kind > 25)
1042 kind = 25;
1043 break;
1044 case 160:
1045 if (curChar == 35)
1046 jjCheckNAdd(168);
1047 break;
1048 case 162:
1049 if ((0x100002600L & l) != 0L && kind > 26)
1050 kind = 26;
1051 break;
1052 case 169:
1053 if (curChar == 35)
1054 jjCheckNAdd(179);
1055 break;
1056 case 171:
1057 if ((0x100002600L & l) != 0L)
1058 jjAddStates(112, 113);
1059 break;
1060 case 172:
1061 if (curChar == 62 && kind > 27)
1062 kind = 27;
1063 break;
1064 case 180:
1065 if (curChar == 35)
1066 jjCheckNAdd(189);
1067 break;
1068 case 182:
1069 if ((0x100002600L & l) != 0L)
1070 jjAddStates(114, 115);
1071 break;
1072 case 183:
1073 if (curChar == 62 && kind > 28)
1074 kind = 28;
1075 break;
1076 case 190:
1077 if (curChar == 35)
1078 jjCheckNAdd(199);
1079 break;
1080 case 192:
1081 if ((0x100002600L & l) != 0L)
1082 jjAddStates(116, 117);
1083 break;
1084 case 193:
1085 if (curChar == 62 && kind > 30)
1086 kind = 30;
1087 break;
1088 case 200:
1089 if (curChar == 35)
1090 jjCheckNAdd(207);
1091 break;
1092 case 202:
1093 if ((0x100002600L & l) != 0L)
1094 jjCheckNAddStates(118, 120);
1095 break;
1096 case 203:
1097 if (curChar == 47)
1098 jjCheckNAdd(204);
1099 break;
1100 case 204:
1101 if (curChar == 62 && kind > 44)
1102 kind = 44;
1103 break;
1104 case 208:
1105 if (curChar == 35)
1106 jjCheckNAdd(216);
1107 break;
1108 case 210:
1109 if ((0x100002600L & l) != 0L)
1110 jjCheckNAddStates(121, 123);
1111 break;
1112 case 211:
1113 if (curChar == 47)
1114 jjCheckNAdd(212);
1115 break;
1116 case 212:
1117 if (curChar == 62 && kind > 45)
1118 kind = 45;
1119 break;
1120 case 217:
1121 if (curChar == 35)
1122 jjCheckNAdd(226);
1123 break;
1124 case 219:
1125 if ((0x100002600L & l) != 0L)
1126 jjCheckNAddStates(124, 126);
1127 break;
1128 case 220:
1129 if (curChar == 47)
1130 jjCheckNAdd(221);
1131 break;
1132 case 221:
1133 if (curChar == 62 && kind > 46)
1134 kind = 46;
1135 break;
1136 case 227:
1137 if (curChar == 35)
1138 jjCheckNAdd(234);
1139 break;
1140 case 229:
1141 if ((0x100002600L & l) != 0L)
1142 jjCheckNAddStates(127, 129);
1143 break;
1144 case 230:
1145 if (curChar == 47)
1146 jjCheckNAdd(231);
1147 break;
1148 case 231:
1149 if (curChar == 62 && kind > 47)
1150 kind = 47;
1151 break;
1152 case 235:
1153 if (curChar == 35)
1154 jjCheckNAdd(243);
1155 break;
1156 case 237:
1157 if ((0x100002600L & l) != 0L)
1158 jjCheckNAddStates(130, 132);
1159 break;
1160 case 238:
1161 if (curChar == 47)
1162 jjCheckNAdd(239);
1163 break;
1164 case 239:
1165 if (curChar == 62 && kind > 48)
1166 kind = 48;
1167 break;
1168 case 244:
1169 if (curChar == 35)
1170 jjCheckNAdd(245);
1171 break;
1172 case 246:
1173 if ((0x100002600L & l) != 0L)
1174 jjCheckNAddStates(133, 135);
1175 break;
1176 case 247:
1177 if (curChar == 47)
1178 jjCheckNAdd(248);
1179 break;
1180 case 248:
1181 if (curChar == 62 && kind > 49)
1182 kind = 49;
1183 break;
1184 case 249:
1185 if (curChar == 35)
1186 jjCheckNAdd(254);
1187 break;
1188 case 251:
1189 if ((0x100002600L & l) != 0L)
1190 jjCheckNAddStates(136, 138);
1191 break;
1192 case 252:
1193 if (curChar == 47)
1194 jjCheckNAdd(253);
1195 break;
1196 case 253:
1197 if (curChar == 62 && kind > 50)
1198 kind = 50;
1199 break;
1200 case 255:
1201 if (curChar == 35)
1202 jjCheckNAdd(260);
1203 break;
1204 case 257:
1205 if ((0x100002600L & l) != 0L)
1206 jjCheckNAddStates(139, 141);
1207 break;
1208 case 258:
1209 if (curChar == 47)
1210 jjCheckNAdd(259);
1211 break;
1212 case 259:
1213 if (curChar == 62 && kind > 51)
1214 kind = 51;
1215 break;
1216 case 261:
1217 if (curChar == 35)
1218 jjCheckNAdd(266);
1219 break;
1220 case 263:
1221 if ((0x100002600L & l) != 0L)
1222 jjCheckNAddStates(142, 144);
1223 break;
1224 case 264:
1225 if (curChar == 47)
1226 jjCheckNAdd(265);
1227 break;
1228 case 265:
1229 if (curChar == 62 && kind > 52)
1230 kind = 52;
1231 break;
1232 case 267:
1233 if (curChar == 35)
1234 jjCheckNAdd(276);
1235 break;
1236 case 269:
1237 if ((0x100002600L & l) != 0L)
1238 jjAddStates(145, 146);
1239 break;
1240 case 270:
1241 if (curChar == 62 && kind > 53)
1242 kind = 53;
1243 break;
1244 case 277:
1245 if (curChar == 35)
1246 jjCheckNAdd(286);
1247 break;
1248 case 279:
1249 if ((0x100002600L & l) != 0L)
1250 jjCheckNAddStates(147, 149);
1251 break;
1252 case 280:
1253 if (curChar == 47)
1254 jjCheckNAdd(281);
1255 break;
1256 case 281:
1257 if (curChar == 62 && kind > 54)
1258 kind = 54;
1259 break;
1260 case 287:
1261 if (curChar == 35)
1262 jjCheckNAdd(294);
1263 break;
1264 case 289:
1265 if ((0x100002600L & l) != 0L && kind > 55)
1266 kind = 55;
1267 break;
1268 case 295:
1269 if (curChar == 35)
1270 jjCheckNAdd(305);
1271 break;
1272 case 297:
1273 if ((0x100002600L & l) != 0L)
1274 jjCheckNAddStates(150, 152);
1275 break;
1276 case 298:
1277 if (curChar == 47)
1278 jjCheckNAdd(299);
1279 break;
1280 case 299:
1281 if (curChar == 62 && kind > 56)
1282 kind = 56;
1283 break;
1284 case 306:
1285 if (curChar == 35)
1286 jjCheckNAdd(314);
1287 break;
1288 case 308:
1289 if ((0x100002600L & l) != 0L && kind > 57)
1290 kind = 57;
1291 break;
1292 case 315:
1293 if (curChar == 35)
1294 jjCheckNAdd(326);
1295 break;
1296 case 317:
1297 if ((0x100002600L & l) != 0L)
1298 jjCheckNAddStates(153, 155);
1299 break;
1300 case 318:
1301 if (curChar == 47)
1302 jjCheckNAdd(319);
1303 break;
1304 case 319:
1305 if (curChar == 62 && kind > 58)
1306 kind = 58;
1307 break;
1308 case 327:
1309 if (curChar == 35)
1310 jjCheckNAdd(334);
1311 break;
1312 case 329:
1313 if ((0x100002600L & l) != 0L && kind > 59)
1314 kind = 59;
1315 break;
1316 case 335:
1317 if (curChar == 35)
1318 jjCheckNAdd(345);
1319 break;
1320 case 337:
1321 if ((0x100002600L & l) != 0L)
1322 jjAddStates(156, 157);
1323 break;
1324 case 338:
1325 if (curChar == 62 && kind > 61)
1326 kind = 61;
1327 break;
1328 case 346:
1329 if (curChar == 47)
1330 jjCheckNAdd(347);
1331 break;
1332 case 347:
1333 if (curChar == 35)
1334 jjstateSet[jjnewStateCnt++] = 348;
1335 break;
1336 case 350:
1337 if ((0x100002600L & l) == 0L)
1338 break;
1339 if (kind > 70)
1340 kind = 70;
1341 jjstateSet[jjnewStateCnt++] = 350;
1342 break;
1343 case 351:
1344 if (curChar == 60)
1345 jjAddStates(5, 22);
1346 break;
1347 case 352:
1348 if (curChar == 47)
1349 jjCheckNAddTwoStates(353, 357);
1350 break;
1351 case 353:
1352 if (curChar == 35)
1353 jjCheckNAdd(357);
1354 break;
1355 case 355:
1356 if ((0x100002600L & l) != 0L)
1357 jjAddStates(158, 159);
1358 break;
1359 case 356:
1360 if (curChar == 62 && kind > 31)
1361 kind = 31;
1362 break;
1363 case 358:
1364 if (curChar == 47)
1365 jjCheckNAddTwoStates(359, 365);
1366 break;
1367 case 359:
1368 if (curChar == 35)
1369 jjCheckNAdd(365);
1370 break;
1371 case 361:
1372 if ((0x100002600L & l) != 0L)
1373 jjAddStates(160, 161);
1374 break;
1375 case 362:
1376 if (curChar == 62 && kind > 32)
1377 kind = 32;
1378 break;
1379 case 366:
1380 if (curChar == 47)
1381 jjCheckNAddTwoStates(367, 376);
1382 break;
1383 case 367:
1384 if (curChar == 35)
1385 jjCheckNAdd(376);
1386 break;
1387 case 369:
1388 if ((0x100002600L & l) != 0L)
1389 jjAddStates(162, 163);
1390 break;
1391 case 370:
1392 if (curChar == 62 && kind > 33)
1393 kind = 33;
1394 break;
1395 case 377:
1396 if (curChar == 47)
1397 jjCheckNAddTwoStates(378, 387);
1398 break;
1399 case 378:
1400 if (curChar == 35)
1401 jjCheckNAdd(387);
1402 break;
1403 case 380:
1404 if ((0x100002600L & l) != 0L)
1405 jjAddStates(164, 165);
1406 break;
1407 case 381:
1408 if (curChar == 62 && kind > 34)
1409 kind = 34;
1410 break;
1411 case 388:
1412 if (curChar == 47)
1413 jjCheckNAddTwoStates(389, 398);
1414 break;
1415 case 389:
1416 if (curChar == 35)
1417 jjCheckNAdd(398);
1418 break;
1419 case 391:
1420 if ((0x100002600L & l) != 0L)
1421 jjAddStates(166, 167);
1422 break;
1423 case 392:
1424 if (curChar == 62 && kind > 35)
1425 kind = 35;
1426 break;
1427 case 399:
1428 if (curChar == 47)
1429 jjCheckNAddTwoStates(400, 407);
1430 break;
1431 case 400:
1432 if (curChar == 35)
1433 jjCheckNAdd(407);
1434 break;
1435 case 402:
1436 if ((0x100002600L & l) != 0L)
1437 jjAddStates(168, 169);
1438 break;
1439 case 403:
1440 if (curChar == 62 && kind > 36)
1441 kind = 36;
1442 break;
1443 case 408:
1444 if (curChar == 47)
1445 jjCheckNAddTwoStates(409, 417);
1446 break;
1447 case 409:
1448 if (curChar == 35)
1449 jjCheckNAdd(417);
1450 break;
1451 case 411:
1452 if ((0x100002600L & l) != 0L)
1453 jjAddStates(170, 171);
1454 break;
1455 case 412:
1456 if (curChar == 62 && kind > 37)
1457 kind = 37;
1458 break;
1459 case 418:
1460 if (curChar == 47)
1461 jjCheckNAddTwoStates(419, 427);
1462 break;
1463 case 419:
1464 if (curChar == 35)
1465 jjCheckNAdd(427);
1466 break;
1467 case 421:
1468 if ((0x100002600L & l) != 0L)
1469 jjAddStates(172, 173);
1470 break;
1471 case 422:
1472 if (curChar == 62 && kind > 38)
1473 kind = 38;
1474 break;
1475 case 428:
1476 if (curChar == 47)
1477 jjCheckNAddTwoStates(429, 439);
1478 break;
1479 case 429:
1480 if (curChar == 35)
1481 jjCheckNAdd(439);
1482 break;
1483 case 431:
1484 if ((0x100002600L & l) != 0L)
1485 jjAddStates(174, 175);
1486 break;
1487 case 432:
1488 if (curChar == 62 && kind > 39)
1489 kind = 39;
1490 break;
1491 case 440:
1492 if (curChar == 47)
1493 jjCheckNAddTwoStates(441, 448);
1494 break;
1495 case 441:
1496 if (curChar == 35)
1497 jjCheckNAdd(448);
1498 break;
1499 case 443:
1500 if ((0x100002600L & l) != 0L)
1501 jjAddStates(176, 177);
1502 break;
1503 case 444:
1504 if (curChar == 62 && kind > 40)
1505 kind = 40;
1506 break;
1507 case 449:
1508 if (curChar == 47)
1509 jjCheckNAddTwoStates(450, 460);
1510 break;
1511 case 450:
1512 if (curChar == 35)
1513 jjCheckNAdd(460);
1514 break;
1515 case 452:
1516 if ((0x100002600L & l) != 0L)
1517 jjAddStates(178, 179);
1518 break;
1519 case 453:
1520 if (curChar == 62 && kind > 41)
1521 kind = 41;
1522 break;
1523 case 461:
1524 if (curChar == 47)
1525 jjCheckNAddTwoStates(462, 473);
1526 break;
1527 case 462:
1528 if (curChar == 35)
1529 jjCheckNAdd(473);
1530 break;
1531 case 464:
1532 if ((0x100002600L & l) != 0L)
1533 jjAddStates(180, 181);
1534 break;
1535 case 465:
1536 if (curChar == 62 && kind > 42)
1537 kind = 42;
1538 break;
1539 case 474:
1540 if (curChar == 47)
1541 jjCheckNAddTwoStates(475, 483);
1542 break;
1543 case 475:
1544 if (curChar == 35)
1545 jjCheckNAdd(483);
1546 break;
1547 case 477:
1548 if ((0x100002600L & l) != 0L)
1549 jjAddStates(182, 183);
1550 break;
1551 case 478:
1552 if (curChar == 62 && kind > 43)
1553 kind = 43;
1554 break;
1555 case 484:
1556 if (curChar == 47)
1557 jjCheckNAddTwoStates(485, 493);
1558 break;
1559 case 485:
1560 if (curChar == 35)
1561 jjCheckNAdd(493);
1562 break;
1563 case 487:
1564 if ((0x100002600L & l) != 0L)
1565 jjAddStates(184, 185);
1566 break;
1567 case 488:
1568 if (curChar == 62 && kind > 60)
1569 kind = 60;
1570 break;
1571 case 494:
1572 if (curChar == 47)
1573 jjCheckNAddTwoStates(495, 505);
1574 break;
1575 case 495:
1576 if (curChar == 35)
1577 jjCheckNAdd(505);
1578 break;
1579 case 497:
1580 if ((0x100002600L & l) != 0L)
1581 jjAddStates(186, 187);
1582 break;
1583 case 498:
1584 if (curChar == 62 && kind > 62)
1585 kind = 62;
1586 break;
1587 case 507:
1588 if (curChar == 36)
1589 jjCheckNAddStates(188, 191);
1590 break;
1591 case 508:
1592 if ((0x3ff001000000000L & l) != 0L)
1593 jjCheckNAddStates(188, 191);
1594 break;
1595 case 509:
1596 if (curChar == 46)
1597 jjstateSet[jjnewStateCnt++] = 510;
1598 break;
1599 case 510:
1600 if (curChar == 36)
1601 jjCheckNAddStates(192, 195);
1602 break;
1603 case 511:
1604 if ((0x3ff001000000000L & l) != 0L)
1605 jjCheckNAddStates(192, 195);
1606 break;
1607 case 512:
1608 if ((0x100002600L & l) != 0L)
1609 jjCheckNAddTwoStates(512, 513);
1610 break;
1611 case 513:
1612 if (curChar == 62 && kind > 64)
1613 kind = 64;
1614 break;
1615 case 514:
1616 if (curChar == 47)
1617 jjstateSet[jjnewStateCnt++] = 506;
1618 break;
1619 case 516:
1620 if ((0x100002600L & l) != 0L && kind > 65)
1621 kind = 65;
1622 break;
1623 case 519:
1624 if (curChar == 35)
1625 jjstateSet[jjnewStateCnt++] = 518;
1626 break;
1627 case 521:
1628 if (curChar == 47)
1629 jjstateSet[jjnewStateCnt++] = 522;
1630 break;
1631 case 522:
1632 if (curChar == 62 && kind > 66)
1633 kind = 66;
1634 break;
1635 case 525:
1636 if (curChar == 35)
1637 jjstateSet[jjnewStateCnt++] = 524;
1638 break;
1639 default : break;
1640 }
1641 } while(i != startsAt);
1642 }
1643 else if (curChar < 128)
1644 {
1645 long l = 1L << (curChar & 077);
1646 MatchLoop: do
1647 {
1648 switch(jjstateSet[--i])
1649 {
1650 case 518:
1651 if ((0x7fffffe87fffffeL & l) != 0L)
1652 {
1653 if (kind > 67)
1654 kind = 67;
1655 jjCheckNAdd(348);
1656 }
1657 if (curChar == 102)
1658 jjstateSet[jjnewStateCnt++] = 523;
1659 else if (curChar == 110)
1660 jjstateSet[jjnewStateCnt++] = 344;
1661 else if (curChar == 101)
1662 jjstateSet[jjnewStateCnt++] = 333;
1663 else if (curChar == 114)
1664 jjstateSet[jjnewStateCnt++] = 313;
1665 else if (curChar == 100)
1666 jjstateSet[jjnewStateCnt++] = 275;
1667 else if (curChar == 108)
1668 jjstateSet[jjnewStateCnt++] = 250;
1669 else if (curChar == 116)
1670 jjAddStates(133, 135);
1671 else if (curChar == 115)
1672 jjstateSet[jjnewStateCnt++] = 233;
1673 else if (curChar == 98)
1674 jjstateSet[jjnewStateCnt++] = 215;
1675 else if (curChar == 99)
1676 jjstateSet[jjnewStateCnt++] = 188;
1677 else if (curChar == 118)
1678 jjstateSet[jjnewStateCnt++] = 138;
1679 else if (curChar == 109)
1680 jjstateSet[jjnewStateCnt++] = 120;
1681 else if (curChar == 105)
1682 jjstateSet[jjnewStateCnt++] = 103;
1683 else if (curChar == 103)
1684 jjstateSet[jjnewStateCnt++] = 79;
1685 else if (curChar == 97)
1686 jjstateSet[jjnewStateCnt++] = 71;
1687 if (curChar == 102)
1688 jjstateSet[jjnewStateCnt++] = 517;
1689 else if (curChar == 114)
1690 jjstateSet[jjnewStateCnt++] = 304;
1691 else if (curChar == 110)
1692 jjstateSet[jjnewStateCnt++] = 293;
1693 else if (curChar == 101)
1694 jjstateSet[jjnewStateCnt++] = 206;
1695 else if (curChar == 99)
1696 jjstateSet[jjnewStateCnt++] = 178;
1697 else if (curChar == 115)
1698 jjstateSet[jjnewStateCnt++] = 167;
1699 else if (curChar == 116)
1700 jjstateSet[jjnewStateCnt++] = 131;
1701 else if (curChar == 105)
1702 jjstateSet[jjnewStateCnt++] = 95;
1703 else if (curChar == 108)
1704 jjstateSet[jjnewStateCnt++] = 86;
1705 else if (curChar == 97)
1706 jjstateSet[jjnewStateCnt++] = 12;
1707 if (curChar == 102)
1708 jjstateSet[jjnewStateCnt++] = 325;
1709 else if (curChar == 110)
1710 jjstateSet[jjnewStateCnt++] = 285;
1711 else if (curChar == 114)
1712 jjstateSet[jjnewStateCnt++] = 256;
1713 else if (curChar == 99)
1714 jjstateSet[jjnewStateCnt++] = 158;
1715 else if (curChar == 115)
1716 jjstateSet[jjnewStateCnt++] = 144;
1717 else if (curChar == 108)
1718 jjstateSet[jjnewStateCnt++] = 40;
1719 else if (curChar == 101)
1720 jjstateSet[jjnewStateCnt++] = 34;
1721 else if (curChar == 105)
1722 jjstateSet[jjnewStateCnt++] = 25;
1723 if (curChar == 110)
1724 jjstateSet[jjnewStateCnt++] = 262;
1725 else if (curChar == 102)
1726 jjstateSet[jjnewStateCnt++] = 242;
1727 else if (curChar == 114)
1728 jjstateSet[jjnewStateCnt++] = 225;
1729 else if (curChar == 99)
1730 jjstateSet[jjnewStateCnt++] = 63;
1731 else if (curChar == 115)
1732 jjstateSet[jjnewStateCnt++] = 57;
1733 if (curChar == 110)
1734 jjstateSet[jjnewStateCnt++] = 198;
1735 else if (curChar == 114)
1736 jjstateSet[jjnewStateCnt++] = 152;
1737 else if (curChar == 102)
1738 jjstateSet[jjnewStateCnt++] = 113;
1739 if (curChar == 102)
1740 jjstateSet[jjnewStateCnt++] = 49;
1741 else if (curChar == 114)
1742 jjstateSet[jjnewStateCnt++] = 22;
1743 break;
1744 case 4:
1745 if (curChar == 64)
1746 jjstateSet[jjnewStateCnt++] = 350;
1747 else if (curChar == 110)
1748 jjstateSet[jjnewStateCnt++] = 344;
1749 else if (curChar == 101)
1750 jjstateSet[jjnewStateCnt++] = 333;
1751 else if (curChar == 102)
1752 jjstateSet[jjnewStateCnt++] = 325;
1753 else if (curChar == 114)
1754 jjstateSet[jjnewStateCnt++] = 313;
1755 else if (curChar == 100)
1756 jjstateSet[jjnewStateCnt++] = 275;
1757 else if (curChar == 108)
1758 jjstateSet[jjnewStateCnt++] = 250;
1759 else if (curChar == 116)
1760 jjAddStates(133, 135);
1761 else if (curChar == 115)
1762 jjstateSet[jjnewStateCnt++] = 233;
1763 else if (curChar == 98)
1764 jjstateSet[jjnewStateCnt++] = 215;
1765 else if (curChar == 99)
1766 jjstateSet[jjnewStateCnt++] = 188;
1767 else if (curChar == 118)
1768 jjstateSet[jjnewStateCnt++] = 138;
1769 else if (curChar == 109)
1770 jjstateSet[jjnewStateCnt++] = 120;
1771 else if (curChar == 105)
1772 jjstateSet[jjnewStateCnt++] = 103;
1773 else if (curChar == 103)
1774 jjstateSet[jjnewStateCnt++] = 79;
1775 else if (curChar == 97)
1776 jjstateSet[jjnewStateCnt++] = 71;
1777 if (curChar == 114)
1778 jjstateSet[jjnewStateCnt++] = 304;
1779 else if (curChar == 110)
1780 jjstateSet[jjnewStateCnt++] = 293;
1781 else if (curChar == 102)
1782 jjstateSet[jjnewStateCnt++] = 242;
1783 else if (curChar == 101)
1784 jjstateSet[jjnewStateCnt++] = 206;
1785 else if (curChar == 99)
1786 jjstateSet[jjnewStateCnt++] = 178;
1787 else if (curChar == 115)
1788 jjstateSet[jjnewStateCnt++] = 167;
1789 else if (curChar == 116)
1790 jjstateSet[jjnewStateCnt++] = 131;
1791 else if (curChar == 105)
1792 jjstateSet[jjnewStateCnt++] = 95;
1793 else if (curChar == 108)
1794 jjstateSet[jjnewStateCnt++] = 86;
1795 else if (curChar == 97)
1796 jjstateSet[jjnewStateCnt++] = 12;
1797 if (curChar == 110)
1798 jjstateSet[jjnewStateCnt++] = 285;
1799 else if (curChar == 114)
1800 jjstateSet[jjnewStateCnt++] = 256;
1801 else if (curChar == 99)
1802 jjstateSet[jjnewStateCnt++] = 158;
1803 else if (curChar == 115)
1804 jjstateSet[jjnewStateCnt++] = 144;
1805 else if (curChar == 102)
1806 jjstateSet[jjnewStateCnt++] = 113;
1807 else if (curChar == 108)
1808 jjstateSet[jjnewStateCnt++] = 40;
1809 else if (curChar == 101)
1810 jjstateSet[jjnewStateCnt++] = 34;
1811 else if (curChar == 105)
1812 jjstateSet[jjnewStateCnt++] = 25;
1813 if (curChar == 110)
1814 jjstateSet[jjnewStateCnt++] = 262;
1815 else if (curChar == 114)
1816 jjstateSet[jjnewStateCnt++] = 225;
1817 else if (curChar == 99)
1818 jjstateSet[jjnewStateCnt++] = 63;
1819 else if (curChar == 115)
1820 jjstateSet[jjnewStateCnt++] = 57;
1821 else if (curChar == 102)
1822 jjstateSet[jjnewStateCnt++] = 49;
1823 if (curChar == 110)
1824 jjstateSet[jjnewStateCnt++] = 198;
1825 else if (curChar == 114)
1826 jjstateSet[jjnewStateCnt++] = 152;
1827 if (curChar == 114)
1828 jjstateSet[jjnewStateCnt++] = 22;
1829 break;
1830 case 2:
1831 if ((0xffffffff7fffffffL & l) != 0L)
1832 {
1833 if (kind > 69)
1834 kind = 69;
1835 jjCheckNAdd(1);
1836 }
1837 else if (curChar == 95)
1838 {
1839 if (kind > 70)
1840 kind = 70;
1841 }
1842 break;
1843 case 1:
1844 if ((0xffffffff7fffffffL & l) == 0L)
1845 break;
1846 if (kind > 69)
1847 kind = 69;
1848 jjCheckNAdd(1);
1849 break;
1850 case 5:
1851 if (curChar == 116)
1852 jjAddStates(108, 109);
1853 break;
1854 case 8:
1855 if (curChar == 112)
1856 jjstateSet[jjnewStateCnt++] = 5;
1857 break;
1858 case 9:
1859 if (curChar == 109)
1860 jjstateSet[jjnewStateCnt++] = 8;
1861 break;
1862 case 10:
1863 if (curChar == 101)
1864 jjstateSet[jjnewStateCnt++] = 9;
1865 break;
1866 case 11:
1867 if (curChar == 116)
1868 jjstateSet[jjnewStateCnt++] = 10;
1869 break;
1870 case 12:
1871 if (curChar == 116)
1872 jjstateSet[jjnewStateCnt++] = 11;
1873 break;
1874 case 13:
1875 if (curChar == 97)
1876 jjstateSet[jjnewStateCnt++] = 12;
1877 break;
1878 case 15:
1879 if (curChar == 114)
1880 jjAddStates(110, 111);
1881 break;
1882 case 18:
1883 if (curChar == 101)
1884 jjstateSet[jjnewStateCnt++] = 15;
1885 break;
1886 case 19:
1887 if (curChar == 118)
1888 jjstateSet[jjnewStateCnt++] = 18;
1889 break;
1890 case 20:
1891 if (curChar == 111)
1892 jjstateSet[jjnewStateCnt++] = 19;
1893 break;
1894 case 21:
1895 if (curChar == 99)
1896 jjstateSet[jjnewStateCnt++] = 20;
1897 break;
1898 case 22:
1899 if (curChar == 101)
1900 jjstateSet[jjnewStateCnt++] = 21;
1901 break;
1902 case 23:
1903 if (curChar == 114)
1904 jjstateSet[jjnewStateCnt++] = 22;
1905 break;
1906 case 25:
1907 if (curChar == 102)
1908 jjstateSet[jjnewStateCnt++] = 26;
1909 break;
1910 case 27:
1911 if (curChar == 105)
1912 jjstateSet[jjnewStateCnt++] = 25;
1913 break;
1914 case 29:
1915 if (curChar == 102)
1916 jjstateSet[jjnewStateCnt++] = 30;
1917 break;
1918 case 31:
1919 if (curChar == 105)
1920 jjstateSet[jjnewStateCnt++] = 29;
1921 break;
1922 case 32:
1923 if (curChar == 101)
1924 jjstateSet[jjnewStateCnt++] = 31;
1925 break;
1926 case 33:
1927 if (curChar == 115)
1928 jjstateSet[jjnewStateCnt++] = 32;
1929 break;
1930 case 34:
1931 if (curChar == 108)
1932 jjstateSet[jjnewStateCnt++] = 33;
1933 break;
1934 case 35:
1935 if (curChar == 101)
1936 jjstateSet[jjnewStateCnt++] = 34;
1937 break;
1938 case 37:
1939 if (curChar == 116)
1940 jjstateSet[jjnewStateCnt++] = 38;
1941 break;
1942 case 39:
1943 if (curChar == 115)
1944 jjstateSet[jjnewStateCnt++] = 37;
1945 break;
1946 case 40:
1947 if (curChar == 105)
1948 jjstateSet[jjnewStateCnt++] = 39;
1949 break;
1950 case 41:
1951 if (curChar == 108)
1952 jjstateSet[jjnewStateCnt++] = 40;
1953 break;
1954 case 43:
1955 if (curChar == 104)
1956 jjstateSet[jjnewStateCnt++] = 44;
1957 break;
1958 case 45:
1959 if (curChar == 99)
1960 jjstateSet[jjnewStateCnt++] = 43;
1961 break;
1962 case 46:
1963 if (curChar == 97)
1964 jjstateSet[jjnewStateCnt++] = 45;
1965 break;
1966 case 47:
1967 if (curChar == 101)
1968 jjstateSet[jjnewStateCnt++] = 46;
1969 break;
1970 case 48:
1971 if (curChar == 114)
1972 jjstateSet[jjnewStateCnt++] = 47;
1973 break;
1974 case 49:
1975 if (curChar == 111)
1976 jjstateSet[jjnewStateCnt++] = 48;
1977 break;
1978 case 50:
1979 if (curChar == 102)
1980 jjstateSet[jjnewStateCnt++] = 49;
1981 break;
1982 case 52:
1983 if (curChar == 104)
1984 jjstateSet[jjnewStateCnt++] = 53;
1985 break;
1986 case 54:
1987 if (curChar == 99)
1988 jjstateSet[jjnewStateCnt++] = 52;
1989 break;
1990 case 55:
1991 if (curChar == 116)
1992 jjstateSet[jjnewStateCnt++] = 54;
1993 break;
1994 case 56:
1995 if (curChar == 105)
1996 jjstateSet[jjnewStateCnt++] = 55;
1997 break;
1998 case 57:
1999 if (curChar == 119)
2000 jjstateSet[jjnewStateCnt++] = 56;
2001 break;
2002 case 58:
2003 if (curChar == 115)
2004 jjstateSet[jjnewStateCnt++] = 57;
2005 break;
2006 case 60:
2007 if (curChar == 101)
2008 jjstateSet[jjnewStateCnt++] = 61;
2009 break;
2010 case 62:
2011 if (curChar == 115)
2012 jjstateSet[jjnewStateCnt++] = 60;
2013 break;
2014 case 63:
2015 if (curChar == 97)
2016 jjstateSet[jjnewStateCnt++] = 62;
2017 break;
2018 case 64:
2019 if (curChar == 99)
2020 jjstateSet[jjnewStateCnt++] = 63;
2021 break;
2022 case 66:
2023 if (curChar == 110)
2024 jjstateSet[jjnewStateCnt++] = 67;
2025 break;
2026 case 68:
2027 if (curChar == 103)
2028 jjstateSet[jjnewStateCnt++] = 66;
2029 break;
2030 case 69:
2031 if (curChar == 105)
2032 jjstateSet[jjnewStateCnt++] = 68;
2033 break;
2034 case 70:
2035 if (curChar == 115)
2036 jjstateSet[jjnewStateCnt++] = 69;
2037 break;
2038 case 71:
2039 if (curChar == 115)
2040 jjstateSet[jjnewStateCnt++] = 70;
2041 break;
2042 case 72:
2043 if (curChar == 97)
2044 jjstateSet[jjnewStateCnt++] = 71;
2045 break;
2046 case 74:
2047 if (curChar == 108)
2048 jjstateSet[jjnewStateCnt++] = 75;
2049 break;
2050 case 76:
2051 if (curChar == 97)
2052 jjstateSet[jjnewStateCnt++] = 74;
2053 break;
2054 case 77:
2055 if (curChar == 98)
2056 jjstateSet[jjnewStateCnt++] = 76;
2057 break;
2058 case 78:
2059 if (curChar == 111)
2060 jjstateSet[jjnewStateCnt++] = 77;
2061 break;
2062 case 79:
2063 if (curChar == 108)
2064 jjstateSet[jjnewStateCnt++] = 78;
2065 break;
2066 case 80:
2067 if (curChar == 103)
2068 jjstateSet[jjnewStateCnt++] = 79;
2069 break;
2070 case 82:
2071 if (curChar == 108)
2072 jjstateSet[jjnewStateCnt++] = 83;
2073 break;
2074 case 84:
2075 if (curChar == 97)
2076 jjstateSet[jjnewStateCnt++] = 82;
2077 break;
2078 case 85:
2079 if (curChar == 99)
2080 jjstateSet[jjnewStateCnt++] = 84;
2081 break;
2082 case 86:
2083 if (curChar == 111)
2084 jjstateSet[jjnewStateCnt++] = 85;
2085 break;
2086 case 87:
2087 if (curChar == 108)
2088 jjstateSet[jjnewStateCnt++] = 86;
2089 break;
2090 case 89:
2091 if (curChar == 101)
2092 jjstateSet[jjnewStateCnt++] = 90;
2093 break;
2094 case 91:
2095 if (curChar == 100)
2096 jjstateSet[jjnewStateCnt++] = 89;
2097 break;
2098 case 92:
2099 if (curChar == 117)
2100 jjstateSet[jjnewStateCnt++] = 91;
2101 break;
2102 case 93:
2103 if (curChar == 108)
2104 jjstateSet[jjnewStateCnt++] = 92;
2105 break;
2106 case 94:
2107 if (curChar == 99)
2108 jjstateSet[jjnewStateCnt++] = 93;
2109 break;
2110 case 95:
2111 if (curChar == 110)
2112 jjstateSet[jjnewStateCnt++] = 94;
2113 break;
2114 case 96:
2115 if (curChar == 105)
2116 jjstateSet[jjnewStateCnt++] = 95;
2117 break;
2118 case 98:
2119 if (curChar == 116)
2120 jjstateSet[jjnewStateCnt++] = 99;
2121 break;
2122 case 100:
2123 if (curChar == 114)
2124 jjstateSet[jjnewStateCnt++] = 98;
2125 break;
2126 case 101:
2127 if (curChar == 111)
2128 jjstateSet[jjnewStateCnt++] = 100;
2129 break;
2130 case 102:
2131 if (curChar == 112)
2132 jjstateSet[jjnewStateCnt++] = 101;
2133 break;
2134 case 103:
2135 if (curChar == 109)
2136 jjstateSet[jjnewStateCnt++] = 102;
2137 break;
2138 case 104:
2139 if (curChar == 105)
2140 jjstateSet[jjnewStateCnt++] = 103;
2141 break;
2142 case 106:
2143 if (curChar == 110)
2144 jjstateSet[jjnewStateCnt++] = 107;
2145 break;
2146 case 108:
2147 if (curChar == 111)
2148 jjstateSet[jjnewStateCnt++] = 106;
2149 break;
2150 case 109:
2151 if (curChar == 105)
2152 jjstateSet[jjnewStateCnt++] = 108;
2153 break;
2154 case 110:
2155 if (curChar == 116)
2156 jjstateSet[jjnewStateCnt++] = 109;
2157 break;
2158 case 111:
2159 if (curChar == 99)
2160 jjstateSet[jjnewStateCnt++] = 110;
2161 break;
2162 case 112:
2163 if (curChar == 110)
2164 jjstateSet[jjnewStateCnt++] = 111;
2165 break;
2166 case 113:
2167 if (curChar == 117)
2168 jjstateSet[jjnewStateCnt++] = 112;
2169 break;
2170 case 114:
2171 if (curChar == 102)
2172 jjstateSet[jjnewStateCnt++] = 113;
2173 break;
2174 case 116:
2175 if (curChar == 111)
2176 jjstateSet[jjnewStateCnt++] = 117;
2177 break;
2178 case 118:
2179 if (curChar == 114)
2180 jjstateSet[jjnewStateCnt++] = 116;
2181 break;
2182 case 119:
2183 if (curChar == 99)
2184 jjstateSet[jjnewStateCnt++] = 118;
2185 break;
2186 case 120:
2187 if (curChar == 97)
2188 jjstateSet[jjnewStateCnt++] = 119;
2189 break;
2190 case 121:
2191 if (curChar == 109)
2192 jjstateSet[jjnewStateCnt++] = 120;
2193 break;
2194 case 123:
2195 if (curChar == 109)
2196 jjstateSet[jjnewStateCnt++] = 124;
2197 break;
2198 case 125:
2199 if (curChar == 114)
2200 jjstateSet[jjnewStateCnt++] = 123;
2201 break;
2202 case 126:
2203 if (curChar == 111)
2204 jjstateSet[jjnewStateCnt++] = 125;
2205 break;
2206 case 127:
2207 if (curChar == 102)
2208 jjstateSet[jjnewStateCnt++] = 126;
2209 break;
2210 case 128:
2211 if (curChar == 115)
2212 jjstateSet[jjnewStateCnt++] = 127;
2213 break;
2214 case 129:
2215 if (curChar == 110)
2216 jjstateSet[jjnewStateCnt++] = 128;
2217 break;
2218 case 130:
2219 if (curChar == 97)
2220 jjstateSet[jjnewStateCnt++] = 129;
2221 break;
2222 case 131:
2223 if (curChar == 114)
2224 jjstateSet[jjnewStateCnt++] = 130;
2225 break;
2226 case 132:
2227 if (curChar == 116)
2228 jjstateSet[jjnewStateCnt++] = 131;
2229 break;
2230 case 134:
2231 if (curChar == 116)
2232 jjstateSet[jjnewStateCnt++] = 135;
2233 break;
2234 case 136:
2235 if (curChar == 105)
2236 jjstateSet[jjnewStateCnt++] = 134;
2237 break;
2238 case 137:
2239 if (curChar == 115)
2240 jjstateSet[jjnewStateCnt++] = 136;
2241 break;
2242 case 138:
2243 if (curChar == 105)
2244 jjstateSet[jjnewStateCnt++] = 137;
2245 break;
2246 case 139:
2247 if (curChar == 118)
2248 jjstateSet[jjnewStateCnt++] = 138;
2249 break;
2250 case 141:
2251 if (curChar == 112)
2252 jjstateSet[jjnewStateCnt++] = 142;
2253 break;
2254 case 143:
2255 if (curChar == 111)
2256 jjstateSet[jjnewStateCnt++] = 141;
2257 break;
2258 case 144:
2259 if (curChar == 116)
2260 jjstateSet[jjnewStateCnt++] = 143;
2261 break;
2262 case 145:
2263 if (curChar == 115)
2264 jjstateSet[jjnewStateCnt++] = 144;
2265 break;
2266 case 147:
2267 if (curChar == 110)
2268 jjstateSet[jjnewStateCnt++] = 148;
2269 break;
2270 case 149:
2271 if (curChar == 114)
2272 jjstateSet[jjnewStateCnt++] = 147;
2273 break;
2274 case 150:
2275 if (curChar == 117)
2276 jjstateSet[jjnewStateCnt++] = 149;
2277 break;
2278 case 151:
2279 if (curChar == 116)
2280 jjstateSet[jjnewStateCnt++] = 150;
2281 break;
2282 case 152:
2283 if (curChar == 101)
2284 jjstateSet[jjnewStateCnt++] = 151;
2285 break;
2286 case 153:
2287 if (curChar == 114)
2288 jjstateSet[jjnewStateCnt++] = 152;
2289 break;
2290 case 155:
2291 if (curChar == 108)
2292 jjstateSet[jjnewStateCnt++] = 156;
2293 break;
2294 case 157:
2295 if (curChar == 108)
2296 jjstateSet[jjnewStateCnt++] = 155;
2297 break;
2298 case 158:
2299 if (curChar == 97)
2300 jjstateSet[jjnewStateCnt++] = 157;
2301 break;
2302 case 159:
2303 if (curChar == 99)
2304 jjstateSet[jjnewStateCnt++] = 158;
2305 break;
2306 case 161:
2307 if (curChar == 103)
2308 jjstateSet[jjnewStateCnt++] = 162;
2309 break;
2310 case 163:
2311 if (curChar == 110)
2312 jjstateSet[jjnewStateCnt++] = 161;
2313 break;
2314 case 164:
2315 if (curChar == 105)
2316 jjstateSet[jjnewStateCnt++] = 163;
2317 break;
2318 case 165:
2319 if (curChar == 116)
2320 jjstateSet[jjnewStateCnt++] = 164;
2321 break;
2322 case 166:
2323 if (curChar == 116)
2324 jjstateSet[jjnewStateCnt++] = 165;
2325 break;
2326 case 167:
2327 if (curChar == 101)
2328 jjstateSet[jjnewStateCnt++] = 166;
2329 break;
2330 case 168:
2331 if (curChar == 115)
2332 jjstateSet[jjnewStateCnt++] = 167;
2333 break;
2334 case 170:
2335 if (curChar == 115)
2336 jjAddStates(112, 113);
2337 break;
2338 case 173:
2339 if (curChar == 115)
2340 jjstateSet[jjnewStateCnt++] = 170;
2341 break;
2342 case 174:
2343 if (curChar == 101)
2344 jjstateSet[jjnewStateCnt++] = 173;
2345 break;
2346 case 175:
2347 if (curChar == 114)
2348 jjstateSet[jjnewStateCnt++] = 174;
2349 break;
2350 case 176:
2351 if (curChar == 112)
2352 jjstateSet[jjnewStateCnt++] = 175;
2353 break;
2354 case 177:
2355 if (curChar == 109)
2356 jjstateSet[jjnewStateCnt++] = 176;
2357 break;
2358 case 178:
2359 if (curChar == 111)
2360 jjstateSet[jjnewStateCnt++] = 177;
2361 break;
2362 case 179:
2363 if (curChar == 99)
2364 jjstateSet[jjnewStateCnt++] = 178;
2365 break;
2366 case 181:
2367 if (curChar == 116)
2368 jjAddStates(114, 115);
2369 break;
2370 case 184:
2371 if (curChar == 110)
2372 jjstateSet[jjnewStateCnt++] = 181;
2373 break;
2374 case 185:
2375 if (curChar == 101)
2376 jjstateSet[jjnewStateCnt++] = 184;
2377 break;
2378 case 186:
2379 if (curChar == 109)
2380 jjstateSet[jjnewStateCnt++] = 185;
2381 break;
2382 case 187:
2383 if (curChar == 109)
2384 jjstateSet[jjnewStateCnt++] = 186;
2385 break;
2386 case 188:
2387 if (curChar == 111)
2388 jjstateSet[jjnewStateCnt++] = 187;
2389 break;
2390 case 189:
2391 if (curChar == 99)
2392 jjstateSet[jjnewStateCnt++] = 188;
2393 break;
2394 case 191:
2395 if (curChar == 101)
2396 jjAddStates(116, 117);
2397 break;
2398 case 194:
2399 if (curChar == 115)
2400 jjstateSet[jjnewStateCnt++] = 191;
2401 break;
2402 case 195:
2403 if (curChar == 114)
2404 jjstateSet[jjnewStateCnt++] = 194;
2405 break;
2406 case 196:
2407 if (curChar == 97)
2408 jjstateSet[jjnewStateCnt++] = 195;
2409 break;
2410 case 197:
2411 if (curChar == 112)
2412 jjstateSet[jjnewStateCnt++] = 196;
2413 break;
2414 case 198:
2415 if (curChar == 111)
2416 jjstateSet[jjnewStateCnt++] = 197;
2417 break;
2418 case 199:
2419 if (curChar == 110)
2420 jjstateSet[jjnewStateCnt++] = 198;
2421 break;
2422 case 201:
2423 if (curChar == 101)
2424 jjAddStates(118, 120);
2425 break;
2426 case 205:
2427 if (curChar == 115)
2428 jjstateSet[jjnewStateCnt++] = 201;
2429 break;
2430 case 206:
2431 if (curChar == 108)
2432 jjstateSet[jjnewStateCnt++] = 205;
2433 break;
2434 case 207:
2435 if (curChar == 101)
2436 jjstateSet[jjnewStateCnt++] = 206;
2437 break;
2438 case 209:
2439 if (curChar == 107)
2440 jjAddStates(121, 123);
2441 break;
2442 case 213:
2443 if (curChar == 97)
2444 jjstateSet[jjnewStateCnt++] = 209;
2445 break;
2446 case 214:
2447 if (curChar == 101)
2448 jjstateSet[jjnewStateCnt++] = 213;
2449 break;
2450 case 215:
2451 if (curChar == 114)
2452 jjstateSet[jjnewStateCnt++] = 214;
2453 break;
2454 case 216:
2455 if (curChar == 98)
2456 jjstateSet[jjnewStateCnt++] = 215;
2457 break;
2458 case 218:
2459 if (curChar == 110)
2460 jjAddStates(124, 126);
2461 break;
2462 case 222:
2463 if (curChar == 114)
2464 jjstateSet[jjnewStateCnt++] = 218;
2465 break;
2466 case 223:
2467 if (curChar == 117)
2468 jjstateSet[jjnewStateCnt++] = 222;
2469 break;
2470 case 224:
2471 if (curChar == 116)
2472 jjstateSet[jjnewStateCnt++] = 223;
2473 break;
2474 case 225:
2475 if (curChar == 101)
2476 jjstateSet[jjnewStateCnt++] = 224;
2477 break;
2478 case 226:
2479 if (curChar == 114)
2480 jjstateSet[jjnewStateCnt++] = 225;
2481 break;
2482 case 228:
2483 if (curChar == 112)
2484 jjAddStates(127, 129);
2485 break;
2486 case 232:
2487 if (curChar == 111)
2488 jjstateSet[jjnewStateCnt++] = 228;
2489 break;
2490 case 233:
2491 if (curChar == 116)
2492 jjstateSet[jjnewStateCnt++] = 232;
2493 break;
2494 case 234:
2495 if (curChar == 115)
2496 jjstateSet[jjnewStateCnt++] = 233;
2497 break;
2498 case 236:
2499 if (curChar == 104)
2500 jjAddStates(130, 132);
2501 break;
2502 case 240:
2503 if (curChar == 115)
2504 jjstateSet[jjnewStateCnt++] = 236;
2505 break;
2506 case 241:
2507 if (curChar == 117)
2508 jjstateSet[jjnewStateCnt++] = 240;
2509 break;
2510 case 242:
2511 if (curChar == 108)
2512 jjstateSet[jjnewStateCnt++] = 241;
2513 break;
2514 case 243:
2515 if (curChar == 102)
2516 jjstateSet[jjnewStateCnt++] = 242;
2517 break;
2518 case 245:
2519 if (curChar == 116)
2520 jjAddStates(133, 135);
2521 break;
2522 case 250:
2523 if (curChar == 116)
2524 jjAddStates(136, 138);
2525 break;
2526 case 254:
2527 if (curChar == 108)
2528 jjstateSet[jjnewStateCnt++] = 250;
2529 break;
2530 case 256:
2531 if (curChar == 116)
2532 jjAddStates(139, 141);
2533 break;
2534 case 260:
2535 if (curChar == 114)
2536 jjstateSet[jjnewStateCnt++] = 256;
2537 break;
2538 case 262:
2539 if (curChar == 116)
2540 jjAddStates(142, 144);
2541 break;
2542 case 266:
2543 if (curChar == 110)
2544 jjstateSet[jjnewStateCnt++] = 262;
2545 break;
2546 case 268:
2547 if (curChar == 116)
2548 jjAddStates(145, 146);
2549 break;
2550 case 271:
2551 if (curChar == 108)
2552 jjstateSet[jjnewStateCnt++] = 268;
2553 break;
2554 case 272:
2555 if (curChar == 117)
2556 jjstateSet[jjnewStateCnt++] = 271;
2557 break;
2558 case 273:
2559 if (curChar == 97)
2560 jjstateSet[jjnewStateCnt++] = 272;
2561 break;
2562 case 274:
2563 if (curChar == 102)
2564 jjstateSet[jjnewStateCnt++] = 273;
2565 break;
2566 case 275:
2567 if (curChar == 101)
2568 jjstateSet[jjnewStateCnt++] = 274;
2569 break;
2570 case 276:
2571 if (curChar == 100)
2572 jjstateSet[jjnewStateCnt++] = 275;
2573 break;
2574 case 278:
2575 if (curChar == 100)
2576 jjAddStates(147, 149);
2577 break;
2578 case 282:
2579 if (curChar == 101)
2580 jjstateSet[jjnewStateCnt++] = 278;
2581 break;
2582 case 283:
2583 if (curChar == 116)
2584 jjstateSet[jjnewStateCnt++] = 282;
2585 break;
2586 case 284:
2587 if (curChar == 115)
2588 jjstateSet[jjnewStateCnt++] = 283;
2589 break;
2590 case 285:
2591 if (curChar == 101)
2592 jjstateSet[jjnewStateCnt++] = 284;
2593 break;
2594 case 286:
2595 if (curChar == 110)
2596 jjstateSet[jjnewStateCnt++] = 285;
2597 break;
2598 case 288:
2599 if (curChar == 100)
2600 jjstateSet[jjnewStateCnt++] = 289;
2601 break;
2602 case 290:
2603 if (curChar == 101)
2604 jjstateSet[jjnewStateCnt++] = 288;
2605 break;
2606 case 291:
2607 if (curChar == 116)
2608 jjstateSet[jjnewStateCnt++] = 290;
2609 break;
2610 case 292:
2611 if (curChar == 115)
2612 jjstateSet[jjnewStateCnt++] = 291;
2613 break;
2614 case 293:
2615 if (curChar == 101)
2616 jjstateSet[jjnewStateCnt++] = 292;
2617 break;
2618 case 294:
2619 if (curChar == 110)
2620 jjstateSet[jjnewStateCnt++] = 293;
2621 break;
2622 case 296:
2623 if (curChar == 101)
2624 jjAddStates(150, 152);
2625 break;
2626 case 300:
2627 if (curChar == 115)
2628 jjstateSet[jjnewStateCnt++] = 296;
2629 break;
2630 case 301:
2631 if (curChar == 114)
2632 jjstateSet[jjnewStateCnt++] = 300;
2633 break;
2634 case 302:
2635 if (curChar == 117)
2636 jjstateSet[jjnewStateCnt++] = 301;
2637 break;
2638 case 303:
2639 if (curChar == 99)
2640 jjstateSet[jjnewStateCnt++] = 302;
2641 break;
2642 case 304:
2643 if (curChar == 101)
2644 jjstateSet[jjnewStateCnt++] = 303;
2645 break;
2646 case 305:
2647 if (curChar == 114)
2648 jjstateSet[jjnewStateCnt++] = 304;
2649 break;
2650 case 307:
2651 if (curChar == 101)
2652 jjstateSet[jjnewStateCnt++] = 308;
2653 break;
2654 case 309:
2655 if (curChar == 115)
2656 jjstateSet[jjnewStateCnt++] = 307;
2657 break;
2658 case 310:
2659 if (curChar == 114)
2660 jjstateSet[jjnewStateCnt++] = 309;
2661 break;
2662 case 311:
2663 if (curChar == 117)
2664 jjstateSet[jjnewStateCnt++] = 310;
2665 break;
2666 case 312:
2667 if (curChar == 99)
2668 jjstateSet[jjnewStateCnt++] = 311;
2669 break;
2670 case 313:
2671 if (curChar == 101)
2672 jjstateSet[jjnewStateCnt++] = 312;
2673 break;
2674 case 314:
2675 if (curChar == 114)
2676 jjstateSet[jjnewStateCnt++] = 313;
2677 break;
2678 case 316:
2679 if (curChar == 107)
2680 jjAddStates(153, 155);
2681 break;
2682 case 320:
2683 if (curChar == 99)
2684 jjstateSet[jjnewStateCnt++] = 316;
2685 break;
2686 case 321:
2687 if (curChar == 97)
2688 jjstateSet[jjnewStateCnt++] = 320;
2689 break;
2690 case 322:
2691 if (curChar == 98)
2692 jjstateSet[jjnewStateCnt++] = 321;
2693 break;
2694 case 323:
2695 if (curChar == 108)
2696 jjstateSet[jjnewStateCnt++] = 322;
2697 break;
2698 case 324:
2699 if (curChar == 108)
2700 jjstateSet[jjnewStateCnt++] = 323;
2701 break;
2702 case 325:
2703 if (curChar == 97)
2704 jjstateSet[jjnewStateCnt++] = 324;
2705 break;
2706 case 326:
2707 if (curChar == 102)
2708 jjstateSet[jjnewStateCnt++] = 325;
2709 break;
2710 case 328:
2711 if (curChar == 101)
2712 jjstateSet[jjnewStateCnt++] = 329;
2713 break;
2714 case 330:
2715 if (curChar == 112)
2716 jjstateSet[jjnewStateCnt++] = 328;
2717 break;
2718 case 331:
2719 if (curChar == 97)
2720 jjstateSet[jjnewStateCnt++] = 330;
2721 break;
2722 case 332:
2723 if (curChar == 99)
2724 jjstateSet[jjnewStateCnt++] = 331;
2725 break;
2726 case 333:
2727 if (curChar == 115)
2728 jjstateSet[jjnewStateCnt++] = 332;
2729 break;
2730 case 334:
2731 if (curChar == 101)
2732 jjstateSet[jjnewStateCnt++] = 333;
2733 break;
2734 case 336:
2735 if (curChar == 101)
2736 jjAddStates(156, 157);
2737 break;
2738 case 339:
2739 if (curChar == 112)
2740 jjstateSet[jjnewStateCnt++] = 336;
2741 break;
2742 case 340:
2743 if (curChar == 97)
2744 jjstateSet[jjnewStateCnt++] = 339;
2745 break;
2746 case 341:
2747 if (curChar == 99)
2748 jjstateSet[jjnewStateCnt++] = 340;
2749 break;
2750 case 342:
2751 if (curChar == 115)
2752 jjstateSet[jjnewStateCnt++] = 341;
2753 break;
2754 case 343:
2755 if (curChar == 101)
2756 jjstateSet[jjnewStateCnt++] = 342;
2757 break;
2758 case 344:
2759 if (curChar == 111)
2760 jjstateSet[jjnewStateCnt++] = 343;
2761 break;
2762 case 345:
2763 if (curChar == 110)
2764 jjstateSet[jjnewStateCnt++] = 344;
2765 break;
2766 case 348:
2767 if ((0x7fffffe87fffffeL & l) == 0L)
2768 break;
2769 if (kind > 67)
2770 kind = 67;
2771 jjCheckNAdd(348);
2772 break;
2773 case 349:
2774 if (curChar == 64)
2775 jjstateSet[jjnewStateCnt++] = 350;
2776 break;
2777 case 354:
2778 if (curChar == 102)
2779 jjAddStates(158, 159);
2780 break;
2781 case 357:
2782 if (curChar == 105)
2783 jjstateSet[jjnewStateCnt++] = 354;
2784 break;
2785 case 360:
2786 if (curChar == 116)
2787 jjAddStates(160, 161);
2788 break;
2789 case 363:
2790 if (curChar == 115)
2791 jjstateSet[jjnewStateCnt++] = 360;
2792 break;
2793 case 364:
2794 if (curChar == 105)
2795 jjstateSet[jjnewStateCnt++] = 363;
2796 break;
2797 case 365:
2798 if (curChar == 108)
2799 jjstateSet[jjnewStateCnt++] = 364;
2800 break;
2801 case 368:
2802 if (curChar == 114)
2803 jjAddStates(162, 163);
2804 break;
2805 case 371:
2806 if (curChar == 101)
2807 jjstateSet[jjnewStateCnt++] = 368;
2808 break;
2809 case 372:
2810 if (curChar == 118)
2811 jjstateSet[jjnewStateCnt++] = 371;
2812 break;
2813 case 373:
2814 if (curChar == 111)
2815 jjstateSet[jjnewStateCnt++] = 372;
2816 break;
2817 case 374:
2818 if (curChar == 99)
2819 jjstateSet[jjnewStateCnt++] = 373;
2820 break;
2821 case 375:
2822 if (curChar == 101)
2823 jjstateSet[jjnewStateCnt++] = 374;
2824 break;
2825 case 376:
2826 if (curChar == 114)
2827 jjstateSet[jjnewStateCnt++] = 375;
2828 break;
2829 case 379:
2830 if (curChar == 116)
2831 jjAddStates(164, 165);
2832 break;
2833 case 382:
2834 if (curChar == 112)
2835 jjstateSet[jjnewStateCnt++] = 379;
2836 break;
2837 case 383:
2838 if (curChar == 109)
2839 jjstateSet[jjnewStateCnt++] = 382;
2840 break;
2841 case 384:
2842 if (curChar == 101)
2843 jjstateSet[jjnewStateCnt++] = 383;
2844 break;
2845 case 385:
2846 if (curChar == 116)
2847 jjstateSet[jjnewStateCnt++] = 384;
2848 break;
2849 case 386:
2850 if (curChar == 116)
2851 jjstateSet[jjnewStateCnt++] = 385;
2852 break;
2853 case 387:
2854 if (curChar == 97)
2855 jjstateSet[jjnewStateCnt++] = 386;
2856 break;
2857 case 390:
2858 if (curChar == 104)
2859 jjAddStates(166, 167);
2860 break;
2861 case 393:
2862 if (curChar == 99)
2863 jjstateSet[jjnewStateCnt++] = 390;
2864 break;
2865 case 394:
2866 if (curChar == 97)
2867 jjstateSet[jjnewStateCnt++] = 393;
2868 break;
2869 case 395:
2870 if (curChar == 101)
2871 jjstateSet[jjnewStateCnt++] = 394;
2872 break;
2873 case 396:
2874 if (curChar == 114)
2875 jjstateSet[jjnewStateCnt++] = 395;
2876 break;
2877 case 397:
2878 if (curChar == 111)
2879 jjstateSet[jjnewStateCnt++] = 396;
2880 break;
2881 case 398:
2882 if (curChar == 102)
2883 jjstateSet[jjnewStateCnt++] = 397;
2884 break;
2885 case 401:
2886 if (curChar == 108)
2887 jjAddStates(168, 169);
2888 break;
2889 case 404:
2890 if (curChar == 97)
2891 jjstateSet[jjnewStateCnt++] = 401;
2892 break;
2893 case 405:
2894 if (curChar == 99)
2895 jjstateSet[jjnewStateCnt++] = 404;
2896 break;
2897 case 406:
2898 if (curChar == 111)
2899 jjstateSet[jjnewStateCnt++] = 405;
2900 break;
2901 case 407:
2902 if (curChar == 108)
2903 jjstateSet[jjnewStateCnt++] = 406;
2904 break;
2905 case 410:
2906 if (curChar == 108)
2907 jjAddStates(170, 171);
2908 break;
2909 case 413:
2910 if (curChar == 97)
2911 jjstateSet[jjnewStateCnt++] = 410;
2912 break;
2913 case 414:
2914 if (curChar == 98)
2915 jjstateSet[jjnewStateCnt++] = 413;
2916 break;
2917 case 415:
2918 if (curChar == 111)
2919 jjstateSet[jjnewStateCnt++] = 414;
2920 break;
2921 case 416:
2922 if (curChar == 108)
2923 jjstateSet[jjnewStateCnt++] = 415;
2924 break;
2925 case 417:
2926 if (curChar == 103)
2927 jjstateSet[jjnewStateCnt++] = 416;
2928 break;
2929 case 420:
2930 if (curChar == 110)
2931 jjAddStates(172, 173);
2932 break;
2933 case 423:
2934 if (curChar == 103)
2935 jjstateSet[jjnewStateCnt++] = 420;
2936 break;
2937 case 424:
2938 if (curChar == 105)
2939 jjstateSet[jjnewStateCnt++] = 423;
2940 break;
2941 case 425:
2942 if (curChar == 115)
2943 jjstateSet[jjnewStateCnt++] = 424;
2944 break;
2945 case 426:
2946 if (curChar == 115)
2947 jjstateSet[jjnewStateCnt++] = 425;
2948 break;
2949 case 427:
2950 if (curChar == 97)
2951 jjstateSet[jjnewStateCnt++] = 426;
2952 break;
2953 case 430:
2954 if (curChar == 110)
2955 jjAddStates(174, 175);
2956 break;
2957 case 433:
2958 if (curChar == 111)
2959 jjstateSet[jjnewStateCnt++] = 430;
2960 break;
2961 case 434:
2962 if (curChar == 105)
2963 jjstateSet[jjnewStateCnt++] = 433;
2964 break;
2965 case 435:
2966 if (curChar == 116)
2967 jjstateSet[jjnewStateCnt++] = 434;
2968 break;
2969 case 436:
2970 if (curChar == 99)
2971 jjstateSet[jjnewStateCnt++] = 435;
2972 break;
2973 case 437:
2974 if (curChar == 110)
2975 jjstateSet[jjnewStateCnt++] = 436;
2976 break;
2977 case 438:
2978 if (curChar == 117)
2979 jjstateSet[jjnewStateCnt++] = 437;
2980 break;
2981 case 439:
2982 if (curChar == 102)
2983 jjstateSet[jjnewStateCnt++] = 438;
2984 break;
2985 case 442:
2986 if (curChar == 111)
2987 jjAddStates(176, 177);
2988 break;
2989 case 445:
2990 if (curChar == 114)
2991 jjstateSet[jjnewStateCnt++] = 442;
2992 break;
2993 case 446:
2994 if (curChar == 99)
2995 jjstateSet[jjnewStateCnt++] = 445;
2996 break;
2997 case 447:
2998 if (curChar == 97)
2999 jjstateSet[jjnewStateCnt++] = 446;
3000 break;
3001 case 448:
3002 if (curChar == 109)
3003 jjstateSet[jjnewStateCnt++] = 447;
3004 break;
3005 case 451:
3006 if (curChar == 115)
3007 jjAddStates(178, 179);
3008 break;
3009 case 454:
3010 if (curChar == 115)
3011 jjstateSet[jjnewStateCnt++] = 451;
3012 break;
3013 case 455:
3014 if (curChar == 101)
3015 jjstateSet[jjnewStateCnt++] = 454;
3016 break;
3017 case 456:
3018 if (curChar == 114)
3019 jjstateSet[jjnewStateCnt++] = 455;
3020 break;
3021 case 457:
3022 if (curChar == 112)
3023 jjstateSet[jjnewStateCnt++] = 456;
3024 break;
3025 case 458:
3026 if (curChar == 109)
3027 jjstateSet[jjnewStateCnt++] = 457;
3028 break;
3029 case 459:
3030 if (curChar == 111)
3031 jjstateSet[jjnewStateCnt++] = 458;
3032 break;
3033 case 460:
3034 if (curChar == 99)
3035 jjstateSet[jjnewStateCnt++] = 459;
3036 break;
3037 case 463:
3038 if (curChar == 109)
3039 jjAddStates(180, 181);
3040 break;
3041 case 466:
3042 if (curChar == 114)
3043 jjstateSet[jjnewStateCnt++] = 463;
3044 break;
3045 case 467:
3046 if (curChar == 111)
3047 jjstateSet[jjnewStateCnt++] = 466;
3048 break;
3049 case 468:
3050 if (curChar == 102)
3051 jjstateSet[jjnewStateCnt++] = 467;
3052 break;
3053 case 469:
3054 if (curChar == 115)
3055 jjstateSet[jjnewStateCnt++] = 468;
3056 break;
3057 case 470:
3058 if (curChar == 110)
3059 jjstateSet[jjnewStateCnt++] = 469;
3060 break;
3061 case 471:
3062 if (curChar == 97)
3063 jjstateSet[jjnewStateCnt++] = 470;
3064 break;
3065 case 472:
3066 if (curChar == 114)
3067 jjstateSet[jjnewStateCnt++] = 471;
3068 break;
3069 case 473:
3070 if (curChar == 116)
3071 jjstateSet[jjnewStateCnt++] = 472;
3072 break;
3073 case 476:
3074 if (curChar == 104)
3075 jjAddStates(182, 183);
3076 break;
3077 case 479:
3078 if (curChar == 99)
3079 jjstateSet[jjnewStateCnt++] = 476;
3080 break;
3081 case 480:
3082 if (curChar == 116)
3083 jjstateSet[jjnewStateCnt++] = 479;
3084 break;
3085 case 481:
3086 if (curChar == 105)
3087 jjstateSet[jjnewStateCnt++] = 480;
3088 break;
3089 case 482:
3090 if (curChar == 119)
3091 jjstateSet[jjnewStateCnt++] = 481;
3092 break;
3093 case 483:
3094 if (curChar == 115)
3095 jjstateSet[jjnewStateCnt++] = 482;
3096 break;
3097 case 486:
3098 if (curChar == 101)
3099 jjAddStates(184, 185);
3100 break;
3101 case 489:
3102 if (curChar == 112)
3103 jjstateSet[jjnewStateCnt++] = 486;
3104 break;
3105 case 490:
3106 if (curChar == 97)
3107 jjstateSet[jjnewStateCnt++] = 489;
3108 break;
3109 case 491:
3110 if (curChar == 99)
3111 jjstateSet[jjnewStateCnt++] = 490;
3112 break;
3113 case 492:
3114 if (curChar == 115)
3115 jjstateSet[jjnewStateCnt++] = 491;
3116 break;
3117 case 493:
3118 if (curChar == 101)
3119 jjstateSet[jjnewStateCnt++] = 492;
3120 break;
3121 case 496:
3122 if (curChar == 101)
3123 jjAddStates(186, 187);
3124 break;
3125 case 499:
3126 if (curChar == 112)
3127 jjstateSet[jjnewStateCnt++] = 496;
3128 break;
3129 case 500:
3130 if (curChar == 97)
3131 jjstateSet[jjnewStateCnt++] = 499;
3132 break;
3133 case 501:
3134 if (curChar == 99)
3135 jjstateSet[jjnewStateCnt++] = 500;
3136 break;
3137 case 502:
3138 if (curChar == 115)
3139 jjstateSet[jjnewStateCnt++] = 501;
3140 break;
3141 case 503:
3142 if (curChar == 101)
3143 jjstateSet[jjnewStateCnt++] = 502;
3144 break;
3145 case 504:
3146 if (curChar == 111)
3147 jjstateSet[jjnewStateCnt++] = 503;
3148 break;
3149 case 505:
3150 if (curChar == 110)
3151 jjstateSet[jjnewStateCnt++] = 504;
3152 break;
3153 case 506:
3154 if (curChar == 64)
3155 jjCheckNAddStates(196, 198);
3156 break;
3157 case 507:
3158 case 508:
3159 if ((0x7fffffe87ffffffL & l) != 0L)
3160 jjCheckNAddStates(188, 191);
3161 break;
3162 case 510:
3163 case 511:
3164 if ((0x7fffffe87ffffffL & l) != 0L)
3165 jjCheckNAddStates(192, 195);
3166 break;
3167 case 515:
3168 if (curChar == 108)
3169 jjstateSet[jjnewStateCnt++] = 516;
3170 break;
3171 case 517:
3172 if (curChar == 116)
3173 jjstateSet[jjnewStateCnt++] = 515;
3174 break;
3175 case 520:
3176 if (curChar == 108)
3177 jjAddStates(199, 200);
3178 break;
3179 case 523:
3180 if (curChar == 116)
3181 jjstateSet[jjnewStateCnt++] = 520;
3182 break;
3183 case 524:
3184 if (curChar == 102)
3185 jjstateSet[jjnewStateCnt++] = 523;
3186 break;
3187 default : break;
3188 }
3189 } while(i != startsAt);
3190 }
3191 else
3192 {
3193 int hiByte = (int)(curChar >> 8);
3194 int i1 = hiByte >> 6;
3195 long l1 = 1L << (hiByte & 077);
3196 int i2 = (curChar & 0xff) >> 6;
3197 long l2 = 1L << (curChar & 077);
3198 MatchLoop: do
3199 {
3200 switch(jjstateSet[--i])
3201 {
3202 case 2:
3203 case 1:
3204 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3205 break;
3206 if (kind > 69)
3207 kind = 69;
3208 jjCheckNAdd(1);
3209 break;
3210 case 507:
3211 case 508:
3212 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3213 jjCheckNAddStates(188, 191);
3214 break;
3215 case 510:
3216 case 511:
3217 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3218 jjCheckNAddStates(192, 195);
3219 break;
3220 default : break;
3221 }
3222 } while(i != startsAt);
3223 }
3224 if (kind != 0x7fffffff)
3225 {
3226 jjmatchedKind = kind;
3227 jjmatchedPos = curPos;
3228 kind = 0x7fffffff;
3229 }
3230 ++curPos;
3231 if ((i = jjnewStateCnt) == (startsAt = 526 - (jjnewStateCnt = startsAt)))
3232 return curPos;
3233 try { curChar = input_stream.readChar(); }
3234 catch(java.io.IOException e) { return curPos; }
3235 }
3236}
3237private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
3238{
3239 switch (pos)
3240 {
3241 case 0:
3242 if ((active1 & 0x380000000c0000L) != 0L)
3243 {
3244 jjmatchedKind = 118;
3245 return 29;
3246 }
3247 return -1;
3248 case 1:
3249 if ((active1 & 0x200000000c0000L) != 0L)
3250 {
3251 if (jjmatchedPos != 1)
3252 {
3253 jjmatchedKind = 118;
3254 jjmatchedPos = 1;
3255 }
3256 return 29;
3257 }
3258 if ((active1 & 0x18000000000000L) != 0L)
3259 return 29;
3260 return -1;
3261 case 2:
3262 if ((active1 & 0x200000000c0000L) != 0L)
3263 {
3264 jjmatchedKind = 118;
3265 jjmatchedPos = 2;
3266 return 29;
3267 }
3268 return -1;
3269 case 3:
3270 if ((active1 & 0x80000L) != 0L)
3271 return 29;
3272 if ((active1 & 0x20000000040000L) != 0L)
3273 {
3274 jjmatchedKind = 118;
3275 jjmatchedPos = 3;
3276 return 29;
3277 }
3278 return -1;
3279 default :
3280 return -1;
3281 }
3282}
3283private final int jjStartNfa_2(int pos, long active0, long active1)
3284{
3285 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
3286}
3287private final int jjStartNfaWithStates_2(int pos, int kind, int state)
3288{
3289 jjmatchedKind = kind;
3290 jjmatchedPos = pos;
3291 try { curChar = input_stream.readChar(); }
3292 catch(java.io.IOException e) { return pos + 1; }
3293 return jjMoveNfa_2(state, pos + 1);
3294}
3295private final int jjMoveStringLiteralDfa0_2()
3296{
3297 switch(curChar)
3298 {
3299 case 33:
3300 jjmatchedKind = 105;
3301 return jjMoveStringLiteralDfa1_2(0x8000000L);
3302 case 37:
3303 return jjStopAtPos(0, 102);
3304 case 40:
3305 return jjStopAtPos(0, 111);
3306 case 41:
3307 return jjStopAtPos(0, 112);
3308 case 42:
3309 jjmatchedKind = 98;
3310 return jjMoveStringLiteralDfa1_2(0x800000000L);
3311 case 43:
3312 return jjStopAtPos(0, 96);
3313 case 44:
3314 return jjStopAtPos(0, 106);
3315 case 45:
3316 return jjStopAtPos(0, 97);
3317 case 46:
3318 jjmatchedKind = 86;
3319 return jjMoveStringLiteralDfa1_2(0x1000800000L);
3320 case 47:
3321 jjmatchedKind = 101;
3322 return jjMoveStringLiteralDfa1_2(0x400000000000000L);
3323 case 58:
3324 return jjStopAtPos(0, 108);
3325 case 59:
3326 return jjStopAtPos(0, 107);
3327 case 61:
3328 jjmatchedKind = 89;
3329 return jjMoveStringLiteralDfa1_2(0x4000000L);
3330 case 62:
3331 return jjStopAtPos(0, 121);
3332 case 63:
3333 return jjStopAtPos(0, 88);
3334 case 91:
3335 return jjStopAtPos(0, 109);
3336 case 93:
3337 return jjStopAtPos(0, 110);
3338 case 97:
3339 return jjMoveStringLiteralDfa1_2(0x10000000000000L);
3340 case 102:
3341 return jjMoveStringLiteralDfa1_2(0x40000L);
3342 case 105:
3343 return jjMoveStringLiteralDfa1_2(0x8000000000000L);
3344 case 116:
3345 return jjMoveStringLiteralDfa1_2(0x80000L);
3346 case 117:
3347 return jjMoveStringLiteralDfa1_2(0x20000000000000L);
3348 case 123:
3349 return jjStopAtPos(0, 113);
3350 case 125:
3351 return jjStopAtPos(0, 114);
3352 default :
3353 return jjMoveNfa_2(1, 0);
3354 }
3355}
3356private final int jjMoveStringLiteralDfa1_2(long active1)
3357{
3358 try { curChar = input_stream.readChar(); }
3359 catch(java.io.IOException e) {
3360 jjStopStringLiteralDfa_2(0, 0L, active1);
3361 return 1;
3362 }
3363 switch(curChar)
3364 {
3365 case 42:
3366 if ((active1 & 0x800000000L) != 0L)
3367 return jjStopAtPos(1, 99);
3368 break;
3369 case 46:
3370 if ((active1 & 0x800000L) != 0L)
3371 {
3372 jjmatchedKind = 87;
3373 jjmatchedPos = 1;
3374 }
3375 return jjMoveStringLiteralDfa2_2(active1, 0x1000000000L);
3376 case 61:
3377 if ((active1 & 0x4000000L) != 0L)
3378 return jjStopAtPos(1, 90);
3379 else if ((active1 & 0x8000000L) != 0L)
3380 return jjStopAtPos(1, 91);
3381 break;
3382 case 62:
3383 if ((active1 & 0x400000000000000L) != 0L)
3384 return jjStopAtPos(1, 122);
3385 break;
3386 case 97:
3387 return jjMoveStringLiteralDfa2_2(active1, 0x40000L);
3388 case 110:
3389 if ((active1 & 0x8000000000000L) != 0L)
3390 return jjStartNfaWithStates_2(1, 115, 29);
3391 break;
3392 case 114:
3393 return jjMoveStringLiteralDfa2_2(active1, 0x80000L);
3394 case 115:
3395 if ((active1 & 0x10000000000000L) != 0L)
3396 return jjStartNfaWithStates_2(1, 116, 29);
3397 return jjMoveStringLiteralDfa2_2(active1, 0x20000000000000L);
3398 default :
3399 break;
3400 }
3401 return jjStartNfa_2(0, 0L, active1);
3402}
3403private final int jjMoveStringLiteralDfa2_2(long old1, long active1)
3404{
3405 if (((active1 &= old1)) == 0L)
3406 return jjStartNfa_2(0, 0L, old1);
3407 try { curChar = input_stream.readChar(); }
3408 catch(java.io.IOException e) {
3409 jjStopStringLiteralDfa_2(1, 0L, active1);
3410 return 2;
3411 }
3412 switch(curChar)
3413 {
3414 case 46:
3415 if ((active1 & 0x1000000000L) != 0L)
3416 return jjStopAtPos(2, 100);
3417 break;
3418 case 105:
3419 return jjMoveStringLiteralDfa3_2(active1, 0x20000000000000L);
3420 case 108:
3421 return jjMoveStringLiteralDfa3_2(active1, 0x40000L);
3422 case 117:
3423 return jjMoveStringLiteralDfa3_2(active1, 0x80000L);
3424 default :
3425 break;
3426 }
3427 return jjStartNfa_2(1, 0L, active1);
3428}
3429private final int jjMoveStringLiteralDfa3_2(long old1, long active1)
3430{
3431 if (((active1 &= old1)) == 0L)
3432 return jjStartNfa_2(1, 0L, old1);
3433 try { curChar = input_stream.readChar(); }
3434 catch(java.io.IOException e) {
3435 jjStopStringLiteralDfa_2(2, 0L, active1);
3436 return 3;
3437 }
3438 switch(curChar)
3439 {
3440 case 101:
3441 if ((active1 & 0x80000L) != 0L)
3442 return jjStartNfaWithStates_2(3, 83, 29);
3443 break;
3444 case 110:
3445 return jjMoveStringLiteralDfa4_2(active1, 0x20000000000000L);
3446 case 115:
3447 return jjMoveStringLiteralDfa4_2(active1, 0x40000L);
3448 default :
3449 break;
3450 }
3451 return jjStartNfa_2(2, 0L, active1);
3452}
3453private final int jjMoveStringLiteralDfa4_2(long old1, long active1)
3454{
3455 if (((active1 &= old1)) == 0L)
3456 return jjStartNfa_2(2, 0L, old1);
3457 try { curChar = input_stream.readChar(); }
3458 catch(java.io.IOException e) {
3459 jjStopStringLiteralDfa_2(3, 0L, active1);
3460 return 4;
3461 }
3462 switch(curChar)
3463 {
3464 case 101:
3465 if ((active1 & 0x40000L) != 0L)
3466 return jjStartNfaWithStates_2(4, 82, 29);
3467 break;
3468 case 103:
3469 if ((active1 & 0x20000000000000L) != 0L)
3470 return jjStartNfaWithStates_2(4, 117, 29);
3471 break;
3472 default :
3473 break;
3474 }
3475 return jjStartNfa_2(3, 0L, active1);
3476}
3477private final int jjMoveNfa_2(int startState, int curPos)
3478{
3479 int[] nextStates;
3480 int startsAt = 0;
3481 jjnewStateCnt = 69;
3482 int i = 1;
3483 jjstateSet[0] = startState;
3484 int j, kind = 0x7fffffff;
3485 for (;;)
3486 {
3487 if (++jjround == 0x7fffffff)
3488 ReInitRounds();
3489 if (curChar < 64)
3490 {
3491 long l = 1L << curChar;
3492 MatchLoop: do
3493 {
3494 switch(jjstateSet[--i])
3495 {
3496 case 1:
3497 if ((0x3ff000000000000L & l) != 0L)
3498 {
3499 if (kind > 84)
3500 kind = 84;
3501 jjCheckNAddStates(201, 203);
3502 }
3503 else if ((0x100002600L & l) != 0L)
3504 {
3505 if (kind > 73)
3506 kind = 73;
3507 jjCheckNAdd(0);
3508 }
3509 else if (curChar == 38)
3510 jjAddStates(204, 208);
3511 else if (curChar == 60)
3512 {
3513 if (kind > 92)
3514 kind = 92;
3515 jjstateSet[jjnewStateCnt++] = 31;
3516 }
3517 else if (curChar == 36)
3518 {
3519 if (kind > 118)
3520 kind = 118;
3521 jjCheckNAdd(29);
3522 }
3523 else if (curChar == 39)
3524 jjCheckNAddStates(209, 211);
3525 else if (curChar == 34)
3526 jjCheckNAddStates(212, 214);
3527 if (curChar == 38)
3528 {
3529 if (kind > 103)
3530 kind = 103;
3531 }
3532 else if (curChar == 60)
3533 jjCheckNAdd(22);
3534 break;
3535 case 0:
3536 if ((0x100002600L & l) == 0L)
3537 break;
3538 if (kind > 73)
3539 kind = 73;
3540 jjCheckNAdd(0);
3541 break;
3542 case 2:
3543 if ((0xfffffffbffffffffL & l) != 0L)
3544 jjCheckNAddStates(212, 214);
3545 break;
3546 case 4:
3547 if ((0x9400000000L & l) != 0L)
3548 jjCheckNAddStates(212, 214);
3549 break;
3550 case 5:
3551 if (curChar == 34 && kind > 80)
3552 kind = 80;
3553 break;
3554 case 7:
3555 if ((0x3ff000000000000L & l) != 0L)
3556 jjCheckNAddStates(212, 214);
3557 break;
3558 case 8:
3559 if (curChar == 39)
3560 jjCheckNAddStates(209, 211);
3561 break;
3562 case 9:
3563 if ((0xffffff7fffffffffL & l) != 0L)
3564 jjCheckNAddStates(209, 211);
3565 break;
3566 case 11:
3567 if ((0x9400000000L & l) != 0L)
3568 jjCheckNAddStates(209, 211);
3569 break;
3570 case 12:
3571 if (curChar == 39 && kind > 80)
3572 kind = 80;
3573 break;
3574 case 14:
3575 if ((0x3ff000000000000L & l) != 0L)
3576 jjCheckNAddStates(209, 211);
3577 break;
3578 case 16:
3579 if (curChar == 34)
3580 jjCheckNAddTwoStates(17, 18);
3581 break;
3582 case 17:
3583 if ((0xfffffffbffffffffL & l) != 0L)
3584 jjCheckNAddTwoStates(17, 18);
3585 break;
3586 case 18:
3587 if (curChar == 34 && kind > 81)
3588 kind = 81;
3589 break;
3590 case 19:
3591 if (curChar == 39)
3592 jjCheckNAddTwoStates(20, 21);
3593 break;
3594 case 20:
3595 if ((0xffffff7fffffffffL & l) != 0L)
3596 jjCheckNAddTwoStates(20, 21);
3597 break;
3598 case 21:
3599 if (curChar == 39 && kind > 81)
3600 kind = 81;
3601 break;
3602 case 22:
3603 if (curChar == 61 && kind > 93)
3604 kind = 93;
3605 break;
3606 case 23:
3607 if (curChar == 60)
3608 jjCheckNAdd(22);
3609 break;
3610 case 24:
3611 case 66:
3612 if (curChar == 38 && kind > 103)
3613 kind = 103;
3614 break;
3615 case 28:
3616 if (curChar != 36)
3617 break;
3618 if (kind > 118)
3619 kind = 118;
3620 jjCheckNAdd(29);
3621 break;
3622 case 29:
3623 if ((0x3ff001000000000L & l) == 0L)
3624 break;
3625 if (kind > 118)
3626 kind = 118;
3627 jjCheckNAdd(29);
3628 break;
3629 case 30:
3630 if (curChar != 60)
3631 break;
3632 if (kind > 92)
3633 kind = 92;
3634 jjstateSet[jjnewStateCnt++] = 31;
3635 break;
3636 case 31:
3637 if ((0xa00000000L & l) != 0L)
3638 jjstateSet[jjnewStateCnt++] = 33;
3639 break;
3640 case 32:
3641 if (curChar == 45 && kind > 74)
3642 kind = 74;
3643 break;
3644 case 33:
3645 if (curChar == 45)
3646 jjstateSet[jjnewStateCnt++] = 32;
3647 break;
3648 case 34:
3649 if ((0x3ff000000000000L & l) == 0L)
3650 break;
3651 if (kind > 84)
3652 kind = 84;
3653 jjCheckNAddStates(201, 203);
3654 break;
3655 case 35:
3656 if ((0x3ff000000000000L & l) == 0L)
3657 break;
3658 if (kind > 84)
3659 kind = 84;
3660 jjCheckNAdd(35);
3661 break;
3662 case 36:
3663 if ((0x3ff000000000000L & l) != 0L)
3664 jjCheckNAddTwoStates(36, 37);
3665 break;
3666 case 37:
3667 if (curChar == 46)
3668 jjCheckNAdd(38);
3669 break;
3670 case 38:
3671 if ((0x3ff000000000000L & l) == 0L)
3672 break;
3673 if (kind > 85)
3674 kind = 85;
3675 jjCheckNAdd(38);
3676 break;
3677 case 52:
3678 if (curChar == 38)
3679 jjAddStates(204, 208);
3680 break;
3681 case 53:
3682 if (curChar == 59 && kind > 92)
3683 kind = 92;
3684 break;
3685 case 56:
3686 if (curChar == 59)
3687 jjCheckNAdd(22);
3688 break;
3689 case 59:
3690 if (curChar == 59 && kind > 94)
3691 kind = 94;
3692 break;
3693 case 62:
3694 if (curChar == 61 && kind > 95)
3695 kind = 95;
3696 break;
3697 case 63:
3698 if (curChar == 59)
3699 jjstateSet[jjnewStateCnt++] = 62;
3700 break;
3701 default : break;
3702 }
3703 } while(i != startsAt);
3704 }
3705 else if (curChar < 128)
3706 {
3707 long l = 1L << (curChar & 077);
3708 MatchLoop: do
3709 {
3710 switch(jjstateSet[--i])
3711 {
3712 case 1:
3713 if ((0x7fffffe87ffffffL & l) != 0L)
3714 {
3715 if (kind > 118)
3716 kind = 118;
3717 jjCheckNAdd(29);
3718 }
3719 else if (curChar == 92)
3720 jjAddStates(215, 218);
3721 else if (curChar == 124)
3722 jjstateSet[jjnewStateCnt++] = 26;
3723 if (curChar == 103)
3724 jjCheckNAddTwoStates(47, 68);
3725 else if (curChar == 108)
3726 jjCheckNAddTwoStates(40, 42);
3727 else if (curChar == 124)
3728 {
3729 if (kind > 104)
3730 kind = 104;
3731 }
3732 else if (curChar == 114)
3733 jjAddStates(219, 220);
3734 break;
3735 case 2:
3736 if ((0xffffffffefffffffL & l) != 0L)
3737 jjCheckNAddStates(212, 214);
3738 break;
3739 case 3:
3740 if (curChar == 92)
3741 jjAddStates(221, 222);
3742 break;
3743 case 4:
3744 if ((0x1450c610000000L & l) != 0L)
3745 jjCheckNAddStates(212, 214);
3746 break;
3747 case 6:
3748 if (curChar == 120)
3749 jjstateSet[jjnewStateCnt++] = 7;
3750 break;
3751 case 7:
3752 if ((0x7e0000007eL & l) != 0L)
3753 jjCheckNAddStates(212, 214);
3754 break;
3755 case 9:
3756 if ((0xffffffffefffffffL & l) != 0L)
3757 jjCheckNAddStates(209, 211);
3758 break;
3759 case 10:
3760 if (curChar == 92)
3761 jjAddStates(223, 224);
3762 break;
3763 case 11:
3764 if ((0x1450c610000000L & l) != 0L)
3765 jjCheckNAddStates(209, 211);
3766 break;
3767 case 13:
3768 if (curChar == 120)
3769 jjstateSet[jjnewStateCnt++] = 14;
3770 break;
3771 case 14:
3772 if ((0x7e0000007eL & l) != 0L)
3773 jjCheckNAddStates(209, 211);
3774 break;
3775 case 15:
3776 if (curChar == 114)
3777 jjAddStates(219, 220);
3778 break;
3779 case 17:
3780 jjAddStates(225, 226);
3781 break;
3782 case 20:
3783 jjAddStates(227, 228);
3784 break;
3785 case 25:
3786 case 26:
3787 if (curChar == 124 && kind > 104)
3788 kind = 104;
3789 break;
3790 case 27:
3791 if (curChar == 124)
3792 jjstateSet[jjnewStateCnt++] = 26;
3793 break;
3794 case 28:
3795 case 29:
3796 if ((0x7fffffe87ffffffL & l) == 0L)
3797 break;
3798 if (kind > 118)
3799 kind = 118;
3800 jjCheckNAdd(29);
3801 break;
3802 case 39:
3803 if (curChar == 108)
3804 jjCheckNAddTwoStates(40, 42);
3805 break;
3806 case 40:
3807 if (curChar == 116 && kind > 92)
3808 kind = 92;
3809 break;
3810 case 41:
3811 if (curChar == 101 && kind > 93)
3812 kind = 93;
3813 break;
3814 case 42:
3815 case 45:
3816 if (curChar == 116)
3817 jjCheckNAdd(41);
3818 break;
3819 case 43:
3820 if (curChar == 92)
3821 jjAddStates(215, 218);
3822 break;
3823 case 44:
3824 if (curChar == 108)
3825 jjCheckNAdd(40);
3826 break;
3827 case 46:
3828 if (curChar == 108)
3829 jjstateSet[jjnewStateCnt++] = 45;
3830 break;
3831 case 47:
3832 if (curChar == 116 && kind > 94)
3833 kind = 94;
3834 break;
3835 case 48:
3836 if (curChar == 103)
3837 jjCheckNAdd(47);
3838 break;
3839 case 49:
3840 if (curChar == 101 && kind > 95)
3841 kind = 95;
3842 break;
3843 case 50:
3844 case 68:
3845 if (curChar == 116)
3846 jjCheckNAdd(49);
3847 break;
3848 case 51:
3849 if (curChar == 103)
3850 jjstateSet[jjnewStateCnt++] = 50;
3851 break;
3852 case 54:
3853 if (curChar == 116)
3854 jjstateSet[jjnewStateCnt++] = 53;
3855 break;
3856 case 55:
3857 if (curChar == 108)
3858 jjstateSet[jjnewStateCnt++] = 54;
3859 break;
3860 case 57:
3861 if (curChar == 116)
3862 jjstateSet[jjnewStateCnt++] = 56;
3863 break;
3864 case 58:
3865 if (curChar == 108)
3866 jjstateSet[jjnewStateCnt++] = 57;
3867 break;
3868 case 60:
3869 if (curChar == 116)
3870 jjstateSet[jjnewStateCnt++] = 59;
3871 break;
3872 case 61:
3873 if (curChar == 103)
3874 jjstateSet[jjnewStateCnt++] = 60;
3875 break;
3876 case 64:
3877 if (curChar == 116)
3878 jjstateSet[jjnewStateCnt++] = 63;
3879 break;
3880 case 65:
3881 if (curChar == 103)
3882 jjstateSet[jjnewStateCnt++] = 64;
3883 break;
3884 case 67:
3885 if (curChar == 103)
3886 jjCheckNAddTwoStates(47, 68);
3887 break;
3888 default : break;
3889 }
3890 } while(i != startsAt);
3891 }
3892 else
3893 {
3894 int hiByte = (int)(curChar >> 8);
3895 int i1 = hiByte >> 6;
3896 long l1 = 1L << (hiByte & 077);
3897 int i2 = (curChar & 0xff) >> 6;
3898 long l2 = 1L << (curChar & 077);
3899 MatchLoop: do
3900 {
3901 switch(jjstateSet[--i])
3902 {
3903 case 1:
3904 case 29:
3905 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3906 break;
3907 if (kind > 118)
3908 kind = 118;
3909 jjCheckNAdd(29);
3910 break;
3911 case 2:
3912 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3913 jjAddStates(212, 214);
3914 break;
3915 case 9:
3916 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3917 jjAddStates(209, 211);
3918 break;
3919 case 17:
3920 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3921 jjAddStates(225, 226);
3922 break;
3923 case 20:
3924 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3925 jjAddStates(227, 228);
3926 break;
3927 default : break;
3928 }
3929 } while(i != startsAt);
3930 }
3931 if (kind != 0x7fffffff)
3932 {
3933 jjmatchedKind = kind;
3934 jjmatchedPos = curPos;
3935 kind = 0x7fffffff;
3936 }
3937 ++curPos;
3938 if ((i = jjnewStateCnt) == (startsAt = 69 - (jjnewStateCnt = startsAt)))
3939 return curPos;
3940 try { curChar = input_stream.readChar(); }
3941 catch(java.io.IOException e) { return curPos; }
3942 }
3943}
3944private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1)
3945{
3946 switch (pos)
3947 {
3948 case 0:
3949 if ((active1 & 0x380000000c0000L) != 0L)
3950 {
3951 jjmatchedKind = 118;
3952 return 29;
3953 }
3954 return -1;
3955 case 1:
3956 if ((active1 & 0x200000000c0000L) != 0L)
3957 {
3958 if (jjmatchedPos != 1)
3959 {
3960 jjmatchedKind = 118;
3961 jjmatchedPos = 1;
3962 }
3963 return 29;
3964 }
3965 if ((active1 & 0x18000000000000L) != 0L)
3966 return 29;
3967 return -1;
3968 case 2:
3969 if ((active1 & 0x200000000c0000L) != 0L)
3970 {
3971 jjmatchedKind = 118;
3972 jjmatchedPos = 2;
3973 return 29;
3974 }
3975 return -1;
3976 case 3:
3977 if ((active1 & 0x80000L) != 0L)
3978 return 29;
3979 if ((active1 & 0x20000000040000L) != 0L)
3980 {
3981 jjmatchedKind = 118;
3982 jjmatchedPos = 3;
3983 return 29;
3984 }
3985 return -1;
3986 default :
3987 return -1;
3988 }
3989}
3990private final int jjStartNfa_3(int pos, long active0, long active1)
3991{
3992 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1);
3993}
3994private final int jjStartNfaWithStates_3(int pos, int kind, int state)
3995{
3996 jjmatchedKind = kind;
3997 jjmatchedPos = pos;
3998 try { curChar = input_stream.readChar(); }
3999 catch(java.io.IOException e) { return pos + 1; }
4000 return jjMoveNfa_3(state, pos + 1);
4001}
4002private final int jjMoveStringLiteralDfa0_3()
4003{
4004 switch(curChar)
4005 {
4006 case 33:
4007 jjmatchedKind = 105;
4008 return jjMoveStringLiteralDfa1_3(0x8000000L);
4009 case 37:
4010 return jjStopAtPos(0, 102);
4011 case 40:
4012 return jjStopAtPos(0, 111);
4013 case 41:
4014 return jjStopAtPos(0, 112);
4015 case 42:
4016 jjmatchedKind = 98;
4017 return jjMoveStringLiteralDfa1_3(0x800000000L);
4018 case 43:
4019 return jjStopAtPos(0, 96);
4020 case 44:
4021 return jjStopAtPos(0, 106);
4022 case 45:
4023 return jjStopAtPos(0, 97);
4024 case 46:
4025 jjmatchedKind = 86;
4026 return jjMoveStringLiteralDfa1_3(0x1000800000L);
4027 case 47:
4028 return jjStopAtPos(0, 101);
4029 case 58:
4030 return jjStopAtPos(0, 108);
4031 case 59:
4032 return jjStopAtPos(0, 107);
4033 case 61:
4034 jjmatchedKind = 89;
4035 return jjMoveStringLiteralDfa1_3(0x4000000L);
4036 case 62:
4037 jjmatchedKind = 123;
4038 return jjMoveStringLiteralDfa1_3(0x1000000000000000L);
4039 case 63:
4040 return jjStopAtPos(0, 88);
4041 case 91:
4042 return jjStopAtPos(0, 109);
4043 case 93:
4044 return jjStopAtPos(0, 110);
4045 case 97:
4046 return jjMoveStringLiteralDfa1_3(0x10000000000000L);
4047 case 102:
4048 return jjMoveStringLiteralDfa1_3(0x40000L);
4049 case 105:
4050 return jjMoveStringLiteralDfa1_3(0x8000000000000L);
4051 case 116:
4052 return jjMoveStringLiteralDfa1_3(0x80000L);
4053 case 117:
4054 return jjMoveStringLiteralDfa1_3(0x20000000000000L);
4055 case 123:
4056 return jjStopAtPos(0, 113);
4057 case 125:
4058 return jjStopAtPos(0, 114);
4059 default :
4060 return jjMoveNfa_3(1, 0);
4061 }
4062}
4063private final int jjMoveStringLiteralDfa1_3(long active1)
4064{
4065 try { curChar = input_stream.readChar(); }
4066 catch(java.io.IOException e) {
4067 jjStopStringLiteralDfa_3(0, 0L, active1);
4068 return 1;
4069 }
4070 switch(curChar)
4071 {
4072 case 42:
4073 if ((active1 & 0x800000000L) != 0L)
4074 return jjStopAtPos(1, 99);
4075 break;
4076 case 46:
4077 if ((active1 & 0x800000L) != 0L)
4078 {
4079 jjmatchedKind = 87;
4080 jjmatchedPos = 1;
4081 }
4082 return jjMoveStringLiteralDfa2_3(active1, 0x1000000000L);
4083 case 61:
4084 if ((active1 & 0x4000000L) != 0L)
4085 return jjStopAtPos(1, 90);
4086 else if ((active1 & 0x8000000L) != 0L)
4087 return jjStopAtPos(1, 91);
4088 else if ((active1 & 0x1000000000000000L) != 0L)
4089 return jjStopAtPos(1, 124);
4090 break;
4091 case 97:
4092 return jjMoveStringLiteralDfa2_3(active1, 0x40000L);
4093 case 110:
4094 if ((active1 & 0x8000000000000L) != 0L)
4095 return jjStartNfaWithStates_3(1, 115, 29);
4096 break;
4097 case 114:
4098 return jjMoveStringLiteralDfa2_3(active1, 0x80000L);
4099 case 115:
4100 if ((active1 & 0x10000000000000L) != 0L)
4101 return jjStartNfaWithStates_3(1, 116, 29);
4102 return jjMoveStringLiteralDfa2_3(active1, 0x20000000000000L);
4103 default :
4104 break;
4105 }
4106 return jjStartNfa_3(0, 0L, active1);
4107}
4108private final int jjMoveStringLiteralDfa2_3(long old1, long active1)
4109{
4110 if (((active1 &= old1)) == 0L)
4111 return jjStartNfa_3(0, 0L, old1);
4112 try { curChar = input_stream.readChar(); }
4113 catch(java.io.IOException e) {
4114 jjStopStringLiteralDfa_3(1, 0L, active1);
4115 return 2;
4116 }
4117 switch(curChar)
4118 {
4119 case 46:
4120 if ((active1 & 0x1000000000L) != 0L)
4121 return jjStopAtPos(2, 100);
4122 break;
4123 case 105:
4124 return jjMoveStringLiteralDfa3_3(active1, 0x20000000000000L);
4125 case 108:
4126 return jjMoveStringLiteralDfa3_3(active1, 0x40000L);
4127 case 117:
4128 return jjMoveStringLiteralDfa3_3(active1, 0x80000L);
4129 default :
4130 break;
4131 }
4132 return jjStartNfa_3(1, 0L, active1);
4133}
4134private final int jjMoveStringLiteralDfa3_3(long old1, long active1)
4135{
4136 if (((active1 &= old1)) == 0L)
4137 return jjStartNfa_3(1, 0L, old1);
4138 try { curChar = input_stream.readChar(); }
4139 catch(java.io.IOException e) {
4140 jjStopStringLiteralDfa_3(2, 0L, active1);
4141 return 3;
4142 }
4143 switch(curChar)
4144 {
4145 case 101:
4146 if ((active1 & 0x80000L) != 0L)
4147 return jjStartNfaWithStates_3(3, 83, 29);
4148 break;
4149 case 110:
4150 return jjMoveStringLiteralDfa4_3(active1, 0x20000000000000L);
4151 case 115:
4152 return jjMoveStringLiteralDfa4_3(active1, 0x40000L);
4153 default :
4154 break;
4155 }
4156 return jjStartNfa_3(2, 0L, active1);
4157}
4158private final int jjMoveStringLiteralDfa4_3(long old1, long active1)
4159{
4160 if (((active1 &= old1)) == 0L)
4161 return jjStartNfa_3(2, 0L, old1);
4162 try { curChar = input_stream.readChar(); }
4163 catch(java.io.IOException e) {
4164 jjStopStringLiteralDfa_3(3, 0L, active1);
4165 return 4;
4166 }
4167 switch(curChar)
4168 {
4169 case 101:
4170 if ((active1 & 0x40000L) != 0L)
4171 return jjStartNfaWithStates_3(4, 82, 29);
4172 break;
4173 case 103:
4174 if ((active1 & 0x20000000000000L) != 0L)
4175 return jjStartNfaWithStates_3(4, 117, 29);
4176 break;
4177 default :
4178 break;
4179 }
4180 return jjStartNfa_3(3, 0L, active1);
4181}
4182private final int jjMoveNfa_3(int startState, int curPos)
4183{
4184 int[] nextStates;
4185 int startsAt = 0;
4186 jjnewStateCnt = 69;
4187 int i = 1;
4188 jjstateSet[0] = startState;
4189 int j, kind = 0x7fffffff;
4190 for (;;)
4191 {
4192 if (++jjround == 0x7fffffff)
4193 ReInitRounds();
4194 if (curChar < 64)
4195 {
4196 long l = 1L << curChar;
4197 MatchLoop: do
4198 {
4199 switch(jjstateSet[--i])
4200 {
4201 case 1:
4202 if ((0x3ff000000000000L & l) != 0L)
4203 {
4204 if (kind > 84)
4205 kind = 84;
4206 jjCheckNAddStates(201, 203);
4207 }
4208 else if ((0x100002600L & l) != 0L)
4209 {
4210 if (kind > 73)
4211 kind = 73;
4212 jjCheckNAdd(0);
4213 }
4214 else if (curChar == 38)
4215 jjAddStates(204, 208);
4216 else if (curChar == 60)
4217 {
4218 if (kind > 92)
4219 kind = 92;
4220 jjstateSet[jjnewStateCnt++] = 31;
4221 }
4222 else if (curChar == 36)
4223 {
4224 if (kind > 118)
4225 kind = 118;
4226 jjCheckNAdd(29);
4227 }
4228 else if (curChar == 39)
4229 jjCheckNAddStates(209, 211);
4230 else if (curChar == 34)
4231 jjCheckNAddStates(212, 214);
4232 if (curChar == 38)
4233 {
4234 if (kind > 103)
4235 kind = 103;
4236 }
4237 else if (curChar == 60)
4238 jjCheckNAdd(22);
4239 break;
4240 case 0:
4241 if ((0x100002600L & l) == 0L)
4242 break;
4243 if (kind > 73)
4244 kind = 73;
4245 jjCheckNAdd(0);
4246 break;
4247 case 2:
4248 if ((0xfffffffbffffffffL & l) != 0L)
4249 jjCheckNAddStates(212, 214);
4250 break;
4251 case 4:
4252 if ((0x9400000000L & l) != 0L)
4253 jjCheckNAddStates(212, 214);
4254 break;
4255 case 5:
4256 if (curChar == 34 && kind > 80)
4257 kind = 80;
4258 break;
4259 case 7:
4260 if ((0x3ff000000000000L & l) != 0L)
4261 jjCheckNAddStates(212, 214);
4262 break;
4263 case 8:
4264 if (curChar == 39)
4265 jjCheckNAddStates(209, 211);
4266 break;
4267 case 9:
4268 if ((0xffffff7fffffffffL & l) != 0L)
4269 jjCheckNAddStates(209, 211);
4270 break;
4271 case 11:
4272 if ((0x9400000000L & l) != 0L)
4273 jjCheckNAddStates(209, 211);
4274 break;
4275 case 12:
4276 if (curChar == 39 && kind > 80)
4277 kind = 80;
4278 break;
4279 case 14:
4280 if ((0x3ff000000000000L & l) != 0L)
4281 jjCheckNAddStates(209, 211);
4282 break;
4283 case 16:
4284 if (curChar == 34)
4285 jjCheckNAddTwoStates(17, 18);
4286 break;
4287 case 17:
4288 if ((0xfffffffbffffffffL & l) != 0L)
4289 jjCheckNAddTwoStates(17, 18);
4290 break;
4291 case 18:
4292 if (curChar == 34 && kind > 81)
4293 kind = 81;
4294 break;
4295 case 19:
4296 if (curChar == 39)
4297 jjCheckNAddTwoStates(20, 21);
4298 break;
4299 case 20:
4300 if ((0xffffff7fffffffffL & l) != 0L)
4301 jjCheckNAddTwoStates(20, 21);
4302 break;
4303 case 21:
4304 if (curChar == 39 && kind > 81)
4305 kind = 81;
4306 break;
4307 case 22:
4308 if (curChar == 61 && kind > 93)
4309 kind = 93;
4310 break;
4311 case 23:
4312 if (curChar == 60)
4313 jjCheckNAdd(22);
4314 break;
4315 case 24:
4316 case 66:
4317 if (curChar == 38 && kind > 103)
4318 kind = 103;
4319 break;
4320 case 28:
4321 if (curChar != 36)
4322 break;
4323 if (kind > 118)
4324 kind = 118;
4325 jjCheckNAdd(29);
4326 break;
4327 case 29:
4328 if ((0x3ff001000000000L & l) == 0L)
4329 break;
4330 if (kind > 118)
4331 kind = 118;
4332 jjCheckNAdd(29);
4333 break;
4334 case 30:
4335 if (curChar != 60)
4336 break;
4337 if (kind > 92)
4338 kind = 92;
4339 jjstateSet[jjnewStateCnt++] = 31;
4340 break;
4341 case 31:
4342 if ((0xa00000000L & l) != 0L)
4343 jjstateSet[jjnewStateCnt++] = 33;
4344 break;
4345 case 32:
4346 if (curChar == 45 && kind > 74)
4347 kind = 74;
4348 break;
4349 case 33:
4350 if (curChar == 45)
4351 jjstateSet[jjnewStateCnt++] = 32;
4352 break;
4353 case 34:
4354 if ((0x3ff000000000000L & l) == 0L)
4355 break;
4356 if (kind > 84)
4357 kind = 84;
4358 jjCheckNAddStates(201, 203);
4359 break;
4360 case 35:
4361 if ((0x3ff000000000000L & l) == 0L)
4362 break;
4363 if (kind > 84)
4364 kind = 84;
4365 jjCheckNAdd(35);
4366 break;
4367 case 36:
4368 if ((0x3ff000000000000L & l) != 0L)
4369 jjCheckNAddTwoStates(36, 37);
4370 break;
4371 case 37:
4372 if (curChar == 46)
4373 jjCheckNAdd(38);
4374 break;
4375 case 38:
4376 if ((0x3ff000000000000L & l) == 0L)
4377 break;
4378 if (kind > 85)
4379 kind = 85;
4380 jjCheckNAdd(38);
4381 break;
4382 case 52:
4383 if (curChar == 38)
4384 jjAddStates(204, 208);
4385 break;
4386 case 53:
4387 if (curChar == 59 && kind > 92)
4388 kind = 92;
4389 break;
4390 case 56:
4391 if (curChar == 59)
4392 jjCheckNAdd(22);
4393 break;
4394 case 59:
4395 if (curChar == 59 && kind > 94)
4396 kind = 94;
4397 break;
4398 case 62:
4399 if (curChar == 61 && kind > 95)
4400 kind = 95;
4401 break;
4402 case 63:
4403 if (curChar == 59)
4404 jjstateSet[jjnewStateCnt++] = 62;
4405 break;
4406 default : break;
4407 }
4408 } while(i != startsAt);
4409 }
4410 else if (curChar < 128)
4411 {
4412 long l = 1L << (curChar & 077);
4413 MatchLoop: do
4414 {
4415 switch(jjstateSet[--i])
4416 {
4417 case 1:
4418 if ((0x7fffffe87ffffffL & l) != 0L)
4419 {
4420 if (kind > 118)
4421 kind = 118;
4422 jjCheckNAdd(29);
4423 }
4424 else if (curChar == 92)
4425 jjAddStates(215, 218);
4426 else if (curChar == 124)
4427 jjstateSet[jjnewStateCnt++] = 26;
4428 if (curChar == 103)
4429 jjCheckNAddTwoStates(47, 68);
4430 else if (curChar == 108)
4431 jjCheckNAddTwoStates(40, 42);
4432 else if (curChar == 124)
4433 {
4434 if (kind > 104)
4435 kind = 104;
4436 }
4437 else if (curChar == 114)
4438 jjAddStates(219, 220);
4439 break;
4440 case 2:
4441 if ((0xffffffffefffffffL & l) != 0L)
4442 jjCheckNAddStates(212, 214);
4443 break;
4444 case 3:
4445 if (curChar == 92)
4446 jjAddStates(221, 222);
4447 break;
4448 case 4:
4449 if ((0x1450c610000000L & l) != 0L)
4450 jjCheckNAddStates(212, 214);
4451 break;
4452 case 6:
4453 if (curChar == 120)
4454 jjstateSet[jjnewStateCnt++] = 7;
4455 break;
4456 case 7:
4457 if ((0x7e0000007eL & l) != 0L)
4458 jjCheckNAddStates(212, 214);
4459 break;
4460 case 9:
4461 if ((0xffffffffefffffffL & l) != 0L)
4462 jjCheckNAddStates(209, 211);
4463 break;
4464 case 10:
4465 if (curChar == 92)
4466 jjAddStates(223, 224);
4467 break;
4468 case 11:
4469 if ((0x1450c610000000L & l) != 0L)
4470 jjCheckNAddStates(209, 211);
4471 break;
4472 case 13:
4473 if (curChar == 120)
4474 jjstateSet[jjnewStateCnt++] = 14;
4475 break;
4476 case 14:
4477 if ((0x7e0000007eL & l) != 0L)
4478 jjCheckNAddStates(209, 211);
4479 break;
4480 case 15:
4481 if (curChar == 114)
4482 jjAddStates(219, 220);
4483 break;
4484 case 17:
4485 jjAddStates(225, 226);
4486 break;
4487 case 20:
4488 jjAddStates(227, 228);
4489 break;
4490 case 25:
4491 case 26:
4492 if (curChar == 124 && kind > 104)
4493 kind = 104;
4494 break;
4495 case 27:
4496 if (curChar == 124)
4497 jjstateSet[jjnewStateCnt++] = 26;
4498 break;
4499 case 28:
4500 case 29:
4501 if ((0x7fffffe87ffffffL & l) == 0L)
4502 break;
4503 if (kind > 118)
4504 kind = 118;
4505 jjCheckNAdd(29);
4506 break;
4507 case 39:
4508 if (curChar == 108)
4509 jjCheckNAddTwoStates(40, 42);
4510 break;
4511 case 40:
4512 if (curChar == 116 && kind > 92)
4513 kind = 92;
4514 break;
4515 case 41:
4516 if (curChar == 101 && kind > 93)
4517 kind = 93;
4518 break;
4519 case 42:
4520 case 45:
4521 if (curChar == 116)
4522 jjCheckNAdd(41);
4523 break;
4524 case 43:
4525 if (curChar == 92)
4526 jjAddStates(215, 218);
4527 break;
4528 case 44:
4529 if (curChar == 108)
4530 jjCheckNAdd(40);
4531 break;
4532 case 46:
4533 if (curChar == 108)
4534 jjstateSet[jjnewStateCnt++] = 45;
4535 break;
4536 case 47:
4537 if (curChar == 116 && kind > 94)
4538 kind = 94;
4539 break;
4540 case 48:
4541 if (curChar == 103)
4542 jjCheckNAdd(47);
4543 break;
4544 case 49:
4545 if (curChar == 101 && kind > 95)
4546 kind = 95;
4547 break;
4548 case 50:
4549 case 68:
4550 if (curChar == 116)
4551 jjCheckNAdd(49);
4552 break;
4553 case 51:
4554 if (curChar == 103)
4555 jjstateSet[jjnewStateCnt++] = 50;
4556 break;
4557 case 54:
4558 if (curChar == 116)
4559 jjstateSet[jjnewStateCnt++] = 53;
4560 break;
4561 case 55:
4562 if (curChar == 108)
4563 jjstateSet[jjnewStateCnt++] = 54;
4564 break;
4565 case 57:
4566 if (curChar == 116)
4567 jjstateSet[jjnewStateCnt++] = 56;
4568 break;
4569 case 58:
4570 if (curChar == 108)
4571 jjstateSet[jjnewStateCnt++] = 57;
4572 break;
4573 case 60:
4574 if (curChar == 116)
4575 jjstateSet[jjnewStateCnt++] = 59;
4576 break;
4577 case 61:
4578 if (curChar == 103)
4579 jjstateSet[jjnewStateCnt++] = 60;
4580 break;
4581 case 64:
4582 if (curChar == 116)
4583 jjstateSet[jjnewStateCnt++] = 63;
4584 break;
4585 case 65:
4586 if (curChar == 103)
4587 jjstateSet[jjnewStateCnt++] = 64;
4588 break;
4589 case 67:
4590 if (curChar == 103)
4591 jjCheckNAddTwoStates(47, 68);
4592 break;
4593 default : break;
4594 }
4595 } while(i != startsAt);
4596 }
4597 else
4598 {
4599 int hiByte = (int)(curChar >> 8);
4600 int i1 = hiByte >> 6;
4601 long l1 = 1L << (hiByte & 077);
4602 int i2 = (curChar & 0xff) >> 6;
4603 long l2 = 1L << (curChar & 077);
4604 MatchLoop: do
4605 {
4606 switch(jjstateSet[--i])
4607 {
4608 case 1:
4609 case 29:
4610 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
4611 break;
4612 if (kind > 118)
4613 kind = 118;
4614 jjCheckNAdd(29);
4615 break;
4616 case 2:
4617 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4618 jjAddStates(212, 214);
4619 break;
4620 case 9:
4621 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4622 jjAddStates(209, 211);
4623 break;
4624 case 17:
4625 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4626 jjAddStates(225, 226);
4627 break;
4628 case 20:
4629 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4630 jjAddStates(227, 228);
4631 break;
4632 default : break;
4633 }
4634 } while(i != startsAt);
4635 }
4636 if (kind != 0x7fffffff)
4637 {
4638 jjmatchedKind = kind;
4639 jjmatchedPos = curPos;
4640 kind = 0x7fffffff;
4641 }
4642 ++curPos;
4643 if ((i = jjnewStateCnt) == (startsAt = 69 - (jjnewStateCnt = startsAt)))
4644 return curPos;
4645 try { curChar = input_stream.readChar(); }
4646 catch(java.io.IOException e) { return curPos; }
4647 }
4648}
4649private final int jjStopStringLiteralDfa_4(int pos, long active0, long active1)
4650{
4651 switch (pos)
4652 {
4653 default :
4654 return -1;
4655 }
4656}
4657private final int jjStartNfa_4(int pos, long active0, long active1)
4658{
4659 return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0, active1), pos + 1);
4660}
4661private final int jjStartNfaWithStates_4(int pos, int kind, int state)
4662{
4663 jjmatchedKind = kind;
4664 jjmatchedPos = pos;
4665 try { curChar = input_stream.readChar(); }
4666 catch(java.io.IOException e) { return pos + 1; }
4667 return jjMoveNfa_4(state, pos + 1);
4668}
4669private final int jjMoveStringLiteralDfa0_4()
4670{
4671 switch(curChar)
4672 {
4673 case 45:
4674 jjmatchedKind = 77;
4675 return jjMoveStringLiteralDfa1_4(0x4000L);
4676 default :
4677 return jjMoveNfa_4(0, 0);
4678 }
4679}
4680private final int jjMoveStringLiteralDfa1_4(long active1)
4681{
4682 try { curChar = input_stream.readChar(); }
4683 catch(java.io.IOException e) {
4684 jjStopStringLiteralDfa_4(0, 0L, active1);
4685 return 1;
4686 }
4687 switch(curChar)
4688 {
4689 case 45:
4690 return jjMoveStringLiteralDfa2_4(active1, 0x4000L);
4691 default :
4692 break;
4693 }
4694 return jjStartNfa_4(0, 0L, active1);
4695}
4696private final int jjMoveStringLiteralDfa2_4(long old1, long active1)
4697{
4698 if (((active1 &= old1)) == 0L)
4699 return jjStartNfa_4(0, 0L, old1);
4700 try { curChar = input_stream.readChar(); }
4701 catch(java.io.IOException e) {
4702 jjStopStringLiteralDfa_4(1, 0L, active1);
4703 return 2;
4704 }
4705 switch(curChar)
4706 {
4707 case 62:
4708 if ((active1 & 0x4000L) != 0L)
4709 return jjStopAtPos(2, 78);
4710 break;
4711 default :
4712 break;
4713 }
4714 return jjStartNfa_4(1, 0L, active1);
4715}
4716private final int jjMoveNfa_4(int startState, int curPos)
4717{
4718 int[] nextStates;
4719 int startsAt = 0;
4720 jjnewStateCnt = 1;
4721 int i = 1;
4722 jjstateSet[0] = startState;
4723 int j, kind = 0x7fffffff;
4724 for (;;)
4725 {
4726 if (++jjround == 0x7fffffff)
4727 ReInitRounds();
4728 if (curChar < 64)
4729 {
4730 long l = 1L << curChar;
4731 MatchLoop: do
4732 {
4733 switch(jjstateSet[--i])
4734 {
4735 case 0:
4736 if ((0xbfffdfffffffffffL & l) == 0L)
4737 break;
4738 kind = 75;
4739 jjstateSet[jjnewStateCnt++] = 0;
4740 break;
4741 default : break;
4742 }
4743 } while(i != startsAt);
4744 }
4745 else if (curChar < 128)
4746 {
4747 long l = 1L << (curChar & 077);
4748 MatchLoop: do
4749 {
4750 switch(jjstateSet[--i])
4751 {
4752 case 0:
4753 kind = 75;
4754 jjstateSet[jjnewStateCnt++] = 0;
4755 break;
4756 default : break;
4757 }
4758 } while(i != startsAt);
4759 }
4760 else
4761 {
4762 int hiByte = (int)(curChar >> 8);
4763 int i1 = hiByte >> 6;
4764 long l1 = 1L << (hiByte & 077);
4765 int i2 = (curChar & 0xff) >> 6;
4766 long l2 = 1L << (curChar & 077);
4767 MatchLoop: do
4768 {
4769 switch(jjstateSet[--i])
4770 {
4771 case 0:
4772 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
4773 break;
4774 if (kind > 75)
4775 kind = 75;
4776 jjstateSet[jjnewStateCnt++] = 0;
4777 break;
4778 default : break;
4779 }
4780 } while(i != startsAt);
4781 }
4782 if (kind != 0x7fffffff)
4783 {
4784 jjmatchedKind = kind;
4785 jjmatchedPos = curPos;
4786 kind = 0x7fffffff;
4787 }
4788 ++curPos;
4789 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
4790 return curPos;
4791 try { curChar = input_stream.readChar(); }
4792 catch(java.io.IOException e) { return curPos; }
4793 }
4794}
4795private final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
4796{
4797 switch (pos)
4798 {
4799 case 0:
4800 if ((active1 & 0x380000000c0000L) != 0L)
4801 {
4802 jjmatchedKind = 118;
4803 return 29;
4804 }
4805 return -1;
4806 case 1:
4807 if ((active1 & 0x200000000c0000L) != 0L)
4808 {
4809 if (jjmatchedPos != 1)
4810 {
4811 jjmatchedKind = 118;
4812 jjmatchedPos = 1;
4813 }
4814 return 29;
4815 }
4816 if ((active1 & 0x18000000000000L) != 0L)
4817 return 29;
4818 return -1;
4819 case 2:
4820 if ((active1 & 0x200000000c0000L) != 0L)
4821 {
4822 jjmatchedKind = 118;
4823 jjmatchedPos = 2;
4824 return 29;
4825 }
4826 return -1;
4827 case 3:
4828 if ((active1 & 0x80000L) != 0L)
4829 return 29;
4830 if ((active1 & 0x20000000040000L) != 0L)
4831 {
4832 jjmatchedKind = 118;
4833 jjmatchedPos = 3;
4834 return 29;
4835 }
4836 return -1;
4837 default :
4838 return -1;
4839 }
4840}
4841private final int jjStartNfa_5(int pos, long active0, long active1)
4842{
4843 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
4844}
4845private final int jjStartNfaWithStates_5(int pos, int kind, int state)
4846{
4847 jjmatchedKind = kind;
4848 jjmatchedPos = pos;
4849 try { curChar = input_stream.readChar(); }
4850 catch(java.io.IOException e) { return pos + 1; }
4851 return jjMoveNfa_5(state, pos + 1);
4852}
4853private final int jjMoveStringLiteralDfa0_5()
4854{
4855 switch(curChar)
4856 {
4857 case 33:
4858 jjmatchedKind = 105;
4859 return jjMoveStringLiteralDfa1_5(0x8000000L);
4860 case 37:
4861 return jjStopAtPos(0, 102);
4862 case 40:
4863 return jjStopAtPos(0, 111);
4864 case 41:
4865 return jjStopAtPos(0, 112);
4866 case 42:
4867 jjmatchedKind = 98;
4868 return jjMoveStringLiteralDfa1_5(0x800000000L);
4869 case 43:
4870 return jjStopAtPos(0, 96);
4871 case 44:
4872 return jjStopAtPos(0, 106);
4873 case 45:
4874 return jjStopAtPos(0, 97);
4875 case 46:
4876 jjmatchedKind = 86;
4877 return jjMoveStringLiteralDfa1_5(0x1000800000L);
4878 case 47:
4879 jjmatchedKind = 101;
4880 return jjMoveStringLiteralDfa1_5(0x400000000000000L);
4881 case 58:
4882 return jjStopAtPos(0, 108);
4883 case 59:
4884 return jjStopAtPos(0, 107);
4885 case 61:
4886 jjmatchedKind = 89;
4887 return jjMoveStringLiteralDfa1_5(0x4000000L);
4888 case 62:
4889 return jjStopAtPos(0, 121);
4890 case 63:
4891 return jjStopAtPos(0, 88);
4892 case 91:
4893 return jjStopAtPos(0, 109);
4894 case 93:
4895 return jjStopAtPos(0, 110);
4896 case 97:
4897 return jjMoveStringLiteralDfa1_5(0x10000000000000L);
4898 case 102:
4899 return jjMoveStringLiteralDfa1_5(0x40000L);
4900 case 105:
4901 return jjMoveStringLiteralDfa1_5(0x8000000000000L);
4902 case 116:
4903 return jjMoveStringLiteralDfa1_5(0x80000L);
4904 case 117:
4905 return jjMoveStringLiteralDfa1_5(0x20000000000000L);
4906 case 123:
4907 return jjStopAtPos(0, 113);
4908 case 125:
4909 return jjStopAtPos(0, 114);
4910 default :
4911 return jjMoveNfa_5(0, 0);
4912 }
4913}
4914private final int jjMoveStringLiteralDfa1_5(long active1)
4915{
4916 try { curChar = input_stream.readChar(); }
4917 catch(java.io.IOException e) {
4918 jjStopStringLiteralDfa_5(0, 0L, active1);
4919 return 1;
4920 }
4921 switch(curChar)
4922 {
4923 case 42:
4924 if ((active1 & 0x800000000L) != 0L)
4925 return jjStopAtPos(1, 99);
4926 break;
4927 case 46:
4928 if ((active1 & 0x800000L) != 0L)
4929 {
4930 jjmatchedKind = 87;
4931 jjmatchedPos = 1;
4932 }
4933 return jjMoveStringLiteralDfa2_5(active1, 0x1000000000L);
4934 case 61:
4935 if ((active1 & 0x4000000L) != 0L)
4936 return jjStopAtPos(1, 90);
4937 else if ((active1 & 0x8000000L) != 0L)
4938 return jjStopAtPos(1, 91);
4939 break;
4940 case 62:
4941 if ((active1 & 0x400000000000000L) != 0L)
4942 return jjStopAtPos(1, 122);
4943 break;
4944 case 97:
4945 return jjMoveStringLiteralDfa2_5(active1, 0x40000L);
4946 case 110:
4947 if ((active1 & 0x8000000000000L) != 0L)
4948 return jjStartNfaWithStates_5(1, 115, 29);
4949 break;
4950 case 114:
4951 return jjMoveStringLiteralDfa2_5(active1, 0x80000L);
4952 case 115:
4953 if ((active1 & 0x10000000000000L) != 0L)
4954 return jjStartNfaWithStates_5(1, 116, 29);
4955 return jjMoveStringLiteralDfa2_5(active1, 0x20000000000000L);
4956 default :
4957 break;
4958 }
4959 return jjStartNfa_5(0, 0L, active1);
4960}
4961private final int jjMoveStringLiteralDfa2_5(long old1, long active1)
4962{
4963 if (((active1 &= old1)) == 0L)
4964 return jjStartNfa_5(0, 0L, old1);
4965 try { curChar = input_stream.readChar(); }
4966 catch(java.io.IOException e) {
4967 jjStopStringLiteralDfa_5(1, 0L, active1);
4968 return 2;
4969 }
4970 switch(curChar)
4971 {
4972 case 46:
4973 if ((active1 & 0x1000000000L) != 0L)
4974 return jjStopAtPos(2, 100);
4975 break;
4976 case 105:
4977 return jjMoveStringLiteralDfa3_5(active1, 0x20000000000000L);
4978 case 108:
4979 return jjMoveStringLiteralDfa3_5(active1, 0x40000L);
4980 case 117:
4981 return jjMoveStringLiteralDfa3_5(active1, 0x80000L);
4982 default :
4983 break;
4984 }
4985 return jjStartNfa_5(1, 0L, active1);
4986}
4987private final int jjMoveStringLiteralDfa3_5(long old1, long active1)
4988{
4989 if (((active1 &= old1)) == 0L)
4990 return jjStartNfa_5(1, 0L, old1);
4991 try { curChar = input_stream.readChar(); }
4992 catch(java.io.IOException e) {
4993 jjStopStringLiteralDfa_5(2, 0L, active1);
4994 return 3;
4995 }
4996 switch(curChar)
4997 {
4998 case 101:
4999 if ((active1 & 0x80000L) != 0L)
5000 return jjStartNfaWithStates_5(3, 83, 29);
5001 break;
5002 case 110:
5003 return jjMoveStringLiteralDfa4_5(active1, 0x20000000000000L);
5004 case 115:
5005 return jjMoveStringLiteralDfa4_5(active1, 0x40000L);
5006 default :
5007 break;
5008 }
5009 return jjStartNfa_5(2, 0L, active1);
5010}
5011private final int jjMoveStringLiteralDfa4_5(long old1, long active1)
5012{
5013 if (((active1 &= old1)) == 0L)
5014 return jjStartNfa_5(2, 0L, old1);
5015 try { curChar = input_stream.readChar(); }
5016 catch(java.io.IOException e) {
5017 jjStopStringLiteralDfa_5(3, 0L, active1);
5018 return 4;
5019 }
5020 switch(curChar)
5021 {
5022 case 101:
5023 if ((active1 & 0x40000L) != 0L)
5024 return jjStartNfaWithStates_5(4, 82, 29);
5025 break;
5026 case 103:
5027 if ((active1 & 0x20000000000000L) != 0L)
5028 return jjStartNfaWithStates_5(4, 117, 29);
5029 break;
5030 default :
5031 break;
5032 }
5033 return jjStartNfa_5(3, 0L, active1);
5034}
5035private final int jjMoveNfa_5(int startState, int curPos)
5036{
5037 int[] nextStates;
5038 int startsAt = 0;
5039 jjnewStateCnt = 66;
5040 int i = 1;
5041 jjstateSet[0] = startState;
5042 int j, kind = 0x7fffffff;
5043 for (;;)
5044 {
5045 if (++jjround == 0x7fffffff)
5046 ReInitRounds();
5047 if (curChar < 64)
5048 {
5049 long l = 1L << curChar;
5050 MatchLoop: do
5051 {
5052 switch(jjstateSet[--i])
5053 {
5054 case 0:
5055 if ((0x3ff000000000000L & l) != 0L)
5056 {
5057 if (kind > 84)
5058 kind = 84;
5059 jjCheckNAddStates(229, 231);
5060 }
5061 else if ((0x100002600L & l) != 0L)
5062 {
5063 if (kind > 125)
5064 kind = 125;
5065 jjCheckNAdd(30);
5066 }
5067 else if (curChar == 38)
5068 jjAddStates(232, 236);
5069 else if (curChar == 36)
5070 {
5071 if (kind > 118)
5072 kind = 118;
5073 jjCheckNAdd(29);
5074 }
5075 else if (curChar == 60)
5076 jjCheckNAdd(22);
5077 else if (curChar == 39)
5078 jjCheckNAddStates(237, 239);
5079 else if (curChar == 34)
5080 jjCheckNAddStates(240, 242);
5081 if (curChar == 38)
5082 {
5083 if (kind > 103)
5084 kind = 103;
5085 }
5086 else if (curChar == 60)
5087 {
5088 if (kind > 92)
5089 kind = 92;
5090 }
5091 break;
5092 case 1:
5093 if ((0xfffffffbffffffffL & l) != 0L)
5094 jjCheckNAddStates(240, 242);
5095 break;
5096 case 3:
5097 if ((0x9400000000L & l) != 0L)
5098 jjCheckNAddStates(240, 242);
5099 break;
5100 case 4:
5101 if (curChar == 34 && kind > 80)
5102 kind = 80;
5103 break;
5104 case 6:
5105 if ((0x3ff000000000000L & l) != 0L)
5106 jjCheckNAddStates(240, 242);
5107 break;
5108 case 7:
5109 if (curChar == 39)
5110 jjCheckNAddStates(237, 239);
5111 break;
5112 case 8:
5113 if ((0xffffff7fffffffffL & l) != 0L)
5114 jjCheckNAddStates(237, 239);
5115 break;
5116 case 10:
5117 if ((0x9400000000L & l) != 0L)
5118 jjCheckNAddStates(237, 239);
5119 break;
5120 case 11:
5121 if (curChar == 39 && kind > 80)
5122 kind = 80;
5123 break;
5124 case 13:
5125 if ((0x3ff000000000000L & l) != 0L)
5126 jjCheckNAddStates(237, 239);
5127 break;
5128 case 15:
5129 if (curChar == 34)
5130 jjCheckNAddTwoStates(16, 17);
5131 break;
5132 case 16:
5133 if ((0xfffffffbffffffffL & l) != 0L)
5134 jjCheckNAddTwoStates(16, 17);
5135 break;
5136 case 17:
5137 if (curChar == 34 && kind > 81)
5138 kind = 81;
5139 break;
5140 case 18:
5141 if (curChar == 39)
5142 jjCheckNAddTwoStates(19, 20);
5143 break;
5144 case 19:
5145 if ((0xffffff7fffffffffL & l) != 0L)
5146 jjCheckNAddTwoStates(19, 20);
5147 break;
5148 case 20:
5149 if (curChar == 39 && kind > 81)
5150 kind = 81;
5151 break;
5152 case 21:
5153 if (curChar == 60 && kind > 92)
5154 kind = 92;
5155 break;
5156 case 22:
5157 if (curChar == 61 && kind > 93)
5158 kind = 93;
5159 break;
5160 case 23:
5161 if (curChar == 60)
5162 jjCheckNAdd(22);
5163 break;
5164 case 24:
5165 case 63:
5166 if (curChar == 38 && kind > 103)
5167 kind = 103;
5168 break;
5169 case 28:
5170 if (curChar != 36)
5171 break;
5172 if (kind > 118)
5173 kind = 118;
5174 jjCheckNAdd(29);
5175 break;
5176 case 29:
5177 if ((0x3ff001000000000L & l) == 0L)
5178 break;
5179 if (kind > 118)
5180 kind = 118;
5181 jjCheckNAdd(29);
5182 break;
5183 case 30:
5184 if ((0x100002600L & l) == 0L)
5185 break;
5186 if (kind > 125)
5187 kind = 125;
5188 jjCheckNAdd(30);
5189 break;
5190 case 31:
5191 if ((0x3ff000000000000L & l) == 0L)
5192 break;
5193 if (kind > 84)
5194 kind = 84;
5195 jjCheckNAddStates(229, 231);
5196 break;
5197 case 32:
5198 if ((0x3ff000000000000L & l) == 0L)
5199 break;
5200 if (kind > 84)
5201 kind = 84;
5202 jjCheckNAdd(32);
5203 break;
5204 case 33:
5205 if ((0x3ff000000000000L & l) != 0L)
5206 jjCheckNAddTwoStates(33, 34);
5207 break;
5208 case 34:
5209 if (curChar == 46)
5210 jjCheckNAdd(35);
5211 break;
5212 case 35:
5213 if ((0x3ff000000000000L & l) == 0L)
5214 break;
5215 if (kind > 85)
5216 kind = 85;
5217 jjCheckNAdd(35);
5218 break;
5219 case 49:
5220 if (curChar == 38)
5221 jjAddStates(232, 236);
5222 break;
5223 case 50:
5224 if (curChar == 59 && kind > 92)
5225 kind = 92;
5226 break;
5227 case 53:
5228 if (curChar == 59)
5229 jjCheckNAdd(22);
5230 break;
5231 case 56:
5232 if (curChar == 59 && kind > 94)
5233 kind = 94;
5234 break;
5235 case 59:
5236 if (curChar == 61 && kind > 95)
5237 kind = 95;
5238 break;
5239 case 60:
5240 if (curChar == 59)
5241 jjstateSet[jjnewStateCnt++] = 59;
5242 break;
5243 default : break;
5244 }
5245 } while(i != startsAt);
5246 }
5247 else if (curChar < 128)
5248 {
5249 long l = 1L << (curChar & 077);
5250 MatchLoop: do
5251 {
5252 switch(jjstateSet[--i])
5253 {
5254 case 0:
5255 if ((0x7fffffe87ffffffL & l) != 0L)
5256 {
5257 if (kind > 118)
5258 kind = 118;
5259 jjCheckNAdd(29);
5260 }
5261 else if (curChar == 92)
5262 jjAddStates(243, 246);
5263 else if (curChar == 124)
5264 jjstateSet[jjnewStateCnt++] = 26;
5265 if (curChar == 103)
5266 jjCheckNAddTwoStates(44, 65);
5267 else if (curChar == 108)
5268 jjCheckNAddTwoStates(37, 39);
5269 else if (curChar == 124)
5270 {
5271 if (kind > 104)
5272 kind = 104;
5273 }
5274 else if (curChar == 114)
5275 jjAddStates(247, 248);
5276 break;
5277 case 1:
5278 if ((0xffffffffefffffffL & l) != 0L)
5279 jjCheckNAddStates(240, 242);
5280 break;
5281 case 2:
5282 if (curChar == 92)
5283 jjAddStates(249, 250);
5284 break;
5285 case 3:
5286 if ((0x1450c610000000L & l) != 0L)
5287 jjCheckNAddStates(240, 242);
5288 break;
5289 case 5:
5290 if (curChar == 120)
5291 jjstateSet[jjnewStateCnt++] = 6;
5292 break;
5293 case 6:
5294 if ((0x7e0000007eL & l) != 0L)
5295 jjCheckNAddStates(240, 242);
5296 break;
5297 case 8:
5298 if ((0xffffffffefffffffL & l) != 0L)
5299 jjCheckNAddStates(237, 239);
5300 break;
5301 case 9:
5302 if (curChar == 92)
5303 jjAddStates(251, 252);
5304 break;
5305 case 10:
5306 if ((0x1450c610000000L & l) != 0L)
5307 jjCheckNAddStates(237, 239);
5308 break;
5309 case 12:
5310 if (curChar == 120)
5311 jjstateSet[jjnewStateCnt++] = 13;
5312 break;
5313 case 13:
5314 if ((0x7e0000007eL & l) != 0L)
5315 jjCheckNAddStates(237, 239);
5316 break;
5317 case 14:
5318 if (curChar == 114)
5319 jjAddStates(247, 248);
5320 break;
5321 case 16:
5322 jjAddStates(110, 111);
5323 break;
5324 case 19:
5325 jjAddStates(253, 254);
5326 break;
5327 case 25:
5328 case 26:
5329 if (curChar == 124 && kind > 104)
5330 kind = 104;
5331 break;
5332 case 27:
5333 if (curChar == 124)
5334 jjstateSet[jjnewStateCnt++] = 26;
5335 break;
5336 case 28:
5337 case 29:
5338 if ((0x7fffffe87ffffffL & l) == 0L)
5339 break;
5340 if (kind > 118)
5341 kind = 118;
5342 jjCheckNAdd(29);
5343 break;
5344 case 36:
5345 if (curChar == 108)
5346 jjCheckNAddTwoStates(37, 39);
5347 break;
5348 case 37:
5349 if (curChar == 116 && kind > 92)
5350 kind = 92;
5351 break;
5352 case 38:
5353 if (curChar == 101 && kind > 93)
5354 kind = 93;
5355 break;
5356 case 39:
5357 case 42:
5358 if (curChar == 116)
5359 jjCheckNAdd(38);
5360 break;
5361 case 40:
5362 if (curChar == 92)
5363 jjAddStates(243, 246);
5364 break;
5365 case 41:
5366 if (curChar == 108)
5367 jjCheckNAdd(37);
5368 break;
5369 case 43:
5370 if (curChar == 108)
5371 jjstateSet[jjnewStateCnt++] = 42;
5372 break;
5373 case 44:
5374 if (curChar == 116 && kind > 94)
5375 kind = 94;
5376 break;
5377 case 45:
5378 if (curChar == 103)
5379 jjCheckNAdd(44);
5380 break;
5381 case 46:
5382 if (curChar == 101 && kind > 95)
5383 kind = 95;
5384 break;
5385 case 47:
5386 case 65:
5387 if (curChar == 116)
5388 jjCheckNAdd(46);
5389 break;
5390 case 48:
5391 if (curChar == 103)
5392 jjstateSet[jjnewStateCnt++] = 47;
5393 break;
5394 case 51:
5395 if (curChar == 116)
5396 jjstateSet[jjnewStateCnt++] = 50;
5397 break;
5398 case 52:
5399 if (curChar == 108)
5400 jjstateSet[jjnewStateCnt++] = 51;
5401 break;
5402 case 54:
5403 if (curChar == 116)
5404 jjstateSet[jjnewStateCnt++] = 53;
5405 break;
5406 case 55:
5407 if (curChar == 108)
5408 jjstateSet[jjnewStateCnt++] = 54;
5409 break;
5410 case 57:
5411 if (curChar == 116)
5412 jjstateSet[jjnewStateCnt++] = 56;
5413 break;
5414 case 58:
5415 if (curChar == 103)
5416 jjstateSet[jjnewStateCnt++] = 57;
5417 break;
5418 case 61:
5419 if (curChar == 116)
5420 jjstateSet[jjnewStateCnt++] = 60;
5421 break;
5422 case 62:
5423 if (curChar == 103)
5424 jjstateSet[jjnewStateCnt++] = 61;
5425 break;
5426 case 64:
5427 if (curChar == 103)
5428 jjCheckNAddTwoStates(44, 65);
5429 break;
5430 default : break;
5431 }
5432 } while(i != startsAt);
5433 }
5434 else
5435 {
5436 int hiByte = (int)(curChar >> 8);
5437 int i1 = hiByte >> 6;
5438 long l1 = 1L << (hiByte & 077);
5439 int i2 = (curChar & 0xff) >> 6;
5440 long l2 = 1L << (curChar & 077);
5441 MatchLoop: do
5442 {
5443 switch(jjstateSet[--i])
5444 {
5445 case 0:
5446 case 29:
5447 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
5448 break;
5449 if (kind > 118)
5450 kind = 118;
5451 jjCheckNAdd(29);
5452 break;
5453 case 1:
5454 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5455 jjAddStates(240, 242);
5456 break;
5457 case 8:
5458 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5459 jjAddStates(237, 239);
5460 break;
5461 case 16:
5462 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5463 jjAddStates(110, 111);
5464 break;
5465 case 19:
5466 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5467 jjAddStates(253, 254);
5468 break;
5469 default : break;
5470 }
5471 } while(i != startsAt);
5472 }
5473 if (kind != 0x7fffffff)
5474 {
5475 jjmatchedKind = kind;
5476 jjmatchedPos = curPos;
5477 kind = 0x7fffffff;
5478 }
5479 ++curPos;
5480 if ((i = jjnewStateCnt) == (startsAt = 66 - (jjnewStateCnt = startsAt)))
5481 return curPos;
5482 try { curChar = input_stream.readChar(); }
5483 catch(java.io.IOException e) { return curPos; }
5484 }
5485}
5486static final int[] jjnextStates = {
5487 3, 4, 2, 3, 4, 352, 358, 366, 377, 388, 399, 408, 418, 428, 440, 449,
5488 461, 474, 484, 494, 514, 519, 525, 4, 13, 14, 23, 24, 27, 28, 35, 36,
5489 41, 42, 50, 51, 58, 59, 64, 65, 72, 73, 80, 81, 87, 88, 96, 97,
5490 104, 105, 114, 115, 121, 122, 132, 133, 139, 140, 145, 146, 153, 154, 159, 160,
5491 168, 169, 179, 180, 189, 190, 199, 200, 207, 208, 216, 217, 226, 227, 234, 235,
5492 243, 244, 245, 249, 254, 255, 260, 261, 266, 267, 276, 277, 286, 287, 294, 295,
5493 305, 306, 314, 315, 326, 327, 334, 335, 345, 346, 347, 349, 6, 7, 16, 17,
5494 171, 172, 182, 183, 192, 193, 202, 203, 204, 210, 211, 212, 219, 220, 221, 229,
5495 230, 231, 237, 238, 239, 246, 247, 248, 251, 252, 253, 257, 258, 259, 263, 264,
5496 265, 269, 270, 279, 280, 281, 297, 298, 299, 317, 318, 319, 337, 338, 355, 356,
5497 361, 362, 369, 370, 380, 381, 391, 392, 402, 403, 411, 412, 421, 422, 431, 432,
5498 443, 444, 452, 453, 464, 465, 477, 478, 487, 488, 497, 498, 508, 509, 512, 513,
5499 509, 511, 512, 513, 507, 512, 513, 521, 522, 35, 36, 37, 55, 58, 61, 65,
5500 66, 9, 10, 12, 2, 3, 5, 44, 46, 48, 51, 16, 19, 4, 6, 11,
5501 13, 17, 18, 20, 21, 32, 33, 34, 52, 55, 58, 62, 63, 8, 9, 11,
5502 1, 2, 4, 41, 43, 45, 48, 15, 18, 3, 5, 10, 12, 19, 20,
5503};
5504private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
5505{
5506 switch(hiByte)
5507 {
5508 case 0:
5509 return ((jjbitVec2[i2] & l2) != 0L);
5510 default :
5511 if ((jjbitVec0[i1] & l1) != 0L)
5512 return true;
5513 return false;
5514 }
5515}
5516private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
5517{
5518 switch(hiByte)
5519 {
5520 case 0:
5521 return ((jjbitVec4[i2] & l2) != 0L);
5522 case 48:
5523 return ((jjbitVec5[i2] & l2) != 0L);
5524 case 49:
5525 return ((jjbitVec6[i2] & l2) != 0L);
5526 case 51:
5527 return ((jjbitVec7[i2] & l2) != 0L);
5528 case 61:
5529 return ((jjbitVec8[i2] & l2) != 0L);
5530 default :
5531 if ((jjbitVec3[i1] & l1) != 0L)
5532 return true;
5533 return false;
5534 }
5535}
5536public static final String [] jjstrLiteralImages = {
5537"", null, null, null, null, null, null, null, null, null, null, null, null,
5538null, null, null, null, null, null, null, null, null, null, null, null, null, null,
5539null, null, "\74\43\55\55", null, null, null, null, null, null, null, null, null,
5540null, null, null, null, null, null, null, null, null, null, null, null, null, null,
5541null, null, null, null, null, null, null, null, null, null, "\74\100", null, null,
5542null, null, null, null, null, "\44\173", "\43\173", null, null, null, null, null,
5543null, null, null, null, "\146\141\154\163\145", "\164\162\165\145", null, null,
5544"\56", "\56\56", "\77", "\75", "\75\75", "\41\75", null, null, null, null, "\53",
5545"\55", "\52", "\52\52", "\56\56\56", "\57", "\45", null, null, "\41", "\54", "\73",
5546"\72", "\133", "\135", "\50", "\51", "\173", "\175", "\151\156", "\141\163",
5547"\165\163\151\156\147", null, null, null, "\76", "\57\76", "\76", "\76\75", null, "\55\55\76", null,
5548null, null, };
5549public static final String [] lexStateNames = {
5550 "DEFAULT",
5551 "NODIRECTIVE",
5552 "FM_EXPRESSION",
5553 "IN_PAREN",
5554 "EXPRESSION_COMMENT",
5555 "NO_SPACE_EXPRESSION",
5556 "NO_PARSE",
5557};
5558public static final int[] jjnewLexState = {
5559 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5560 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5561 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, 2, 2, -1, 4,
5562 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5563 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5564 2, -1, -1, -1, -1,
5565};
5566static final long[] jjtoToken = {
5567 0xffffffffffffffc1L, 0xfe7fffffffff01ffL, 0x3L,
5568};
5569static final long[] jjtoSkip = {
5570 0x0L, 0x7e00L, 0x0L,
5571};
5572protected SimpleCharStream input_stream;
5573private final int[] jjrounds = new int[526];
5574private final int[] jjstateSet = new int[1052];
5575StringBuffer image;
5576int jjimageLen;
5577int lengthOfMatch;
5578protected char curChar;
5579public FMParserTokenManager(SimpleCharStream stream)
5580{
5581 if (SimpleCharStream.staticFlag)
5582 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
5583 input_stream = stream;
5584}
5585public FMParserTokenManager(SimpleCharStream stream, int lexState)
5586{
5587 this(stream);
5588 SwitchTo(lexState);
5589}
5590public void ReInit(SimpleCharStream stream)
5591{
5592 jjmatchedPos = jjnewStateCnt = 0;
5593 curLexState = defaultLexState;
5594 input_stream = stream;
5595 ReInitRounds();
5596}
5597private final void ReInitRounds()
5598{
5599 int i;
5600 jjround = 0x80000001;
5601 for (i = 526; i-- > 0;)
5602 jjrounds[i] = 0x80000000;
5603}
5604public void ReInit(SimpleCharStream stream, int lexState)
5605{
5606 ReInit(stream);
5607 SwitchTo(lexState);
5608}
5609public void SwitchTo(int lexState)
5610{
5611 if (lexState >= 7 || lexState < 0)
5612 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
5613 else
5614 curLexState = lexState;
5615}
5616
5617protected Token jjFillToken()
5618{
5619 Token t = Token.newToken(jjmatchedKind);
5620 t.kind = jjmatchedKind;
5621 String im = jjstrLiteralImages[jjmatchedKind];
5622 t.image = (im == null) ? input_stream.GetImage() : im;
5623 t.beginLine = input_stream.getBeginLine();
5624 t.beginColumn = input_stream.getBeginColumn();
5625 t.endLine = input_stream.getEndLine();
5626 t.endColumn = input_stream.getEndColumn();
5627 return t;
5628}
5629
5630int curLexState = 0;
5631int defaultLexState = 0;
5632int jjnewStateCnt;
5633int jjround;
5634int jjmatchedPos;
5635int jjmatchedKind;
5636
5637public Token getNextToken()
5638{
5639 int kind;
5640 Token specialToken = null;
5641 Token matchedToken;
5642 int curPos = 0;
5643
5644 EOFLoop :
5645 for (;;)
5646 {
5647 try
5648 {
5649 curChar = input_stream.BeginToken();
5650 }
5651 catch(java.io.IOException e)
5652 {
5653 jjmatchedKind = 0;
5654 matchedToken = jjFillToken();
5655 return matchedToken;
5656 }
5657 image = null;
5658 jjimageLen = 0;
5659
5660 switch(curLexState)
5661 {
5662 case 0:
5663 jjmatchedKind = 0x7fffffff;
5664 jjmatchedPos = 0;
5665 curPos = jjMoveStringLiteralDfa0_0();
5666 break;
5667 case 1:
5668 jjmatchedKind = 0x7fffffff;
5669 jjmatchedPos = 0;
5670 curPos = jjMoveStringLiteralDfa0_1();
5671 break;
5672 case 2:
5673 jjmatchedKind = 0x7fffffff;
5674 jjmatchedPos = 0;
5675 curPos = jjMoveStringLiteralDfa0_2();
5676 break;
5677 case 3:
5678 jjmatchedKind = 0x7fffffff;
5679 jjmatchedPos = 0;
5680 curPos = jjMoveStringLiteralDfa0_3();
5681 break;
5682 case 4:
5683 try { input_stream.backup(0);
5684 while (curChar <= 62 && (0x4000000000000000L & (1L << curChar)) != 0L)
5685 curChar = input_stream.BeginToken();
5686 }
5687 catch (java.io.IOException e1) { continue EOFLoop; }
5688 jjmatchedKind = 0x7fffffff;
5689 jjmatchedPos = 0;
5690 curPos = jjMoveStringLiteralDfa0_4();
5691 break;
5692 case 5:
5693 jjmatchedKind = 0x7fffffff;
5694 jjmatchedPos = 0;
5695 curPos = jjMoveStringLiteralDfa0_5();
5696 break;
5697 case 6:
5698 jjmatchedKind = 0x7fffffff;
5699 jjmatchedPos = 0;
5700 curPos = jjMoveStringLiteralDfa0_6();
5701 break;
5702 }
5703 if (jjmatchedKind != 0x7fffffff)
5704 {
5705 if (jjmatchedPos + 1 < curPos)
5706 input_stream.backup(curPos - jjmatchedPos - 1);
5707 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
5708 {
5709 matchedToken = jjFillToken();
5710 TokenLexicalActions(matchedToken);
5711 if (jjnewLexState[jjmatchedKind] != -1)
5712 curLexState = jjnewLexState[jjmatchedKind];
5713 return matchedToken;
5714 }
5715 else
5716 {
5717 SkipLexicalActions(null);
5718 if (jjnewLexState[jjmatchedKind] != -1)
5719 curLexState = jjnewLexState[jjmatchedKind];
5720 continue EOFLoop;
5721 }
5722 }
5723 int error_line = input_stream.getEndLine();
5724 int error_column = input_stream.getEndColumn();
5725 String error_after = null;
5726 boolean EOFSeen = false;
5727 try { input_stream.readChar(); input_stream.backup(1); }
5728 catch (java.io.IOException e1) {
5729 EOFSeen = true;
5730 error_after = curPos <= 1 ? "" : input_stream.GetImage();
5731 if (curChar == '\n' || curChar == '\r') {
5732 error_line++;
5733 error_column = 0;
5734 }
5735 else
5736 error_column++;
5737 }
5738 if (!EOFSeen) {
5739 input_stream.backup(1);
5740 error_after = curPos <= 1 ? "" : input_stream.GetImage();
5741 }
5742 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
5743 }
5744}
5745
5746void SkipLexicalActions(Token matchedToken)
5747{
5748 switch(jjmatchedKind)
5749 {
5750 case 78 :
5751 if (image == null)
5752 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5753 else
5754 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5755 if (parenthesisNesting >0) SwitchTo(IN_PAREN); else SwitchTo(FM_EXPRESSION);
5756 break;
5757 default :
5758 break;
5759 }
5760}
5761void TokenLexicalActions(Token matchedToken)
5762{
5763 switch(jjmatchedKind)
5764 {
5765 case 6 :
5766 if (image == null)
5767 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5768 else
5769 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5770 strictSyntaxCheck(matchedToken, DEFAULT);
5771 break;
5772 case 7 :
5773 if (image == null)
5774 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5775 else
5776 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5777 strictSyntaxCheck(matchedToken, DEFAULT);
5778 break;
5779 case 8 :
5780 if (image == null)
5781 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5782 else
5783 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5784 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5785 break;
5786 case 9 :
5787 if (image == null)
5788 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5789 else
5790 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5791 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5792 break;
5793 case 10 :
5794 if (image == null)
5795 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5796 else
5797 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5798 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5799 break;
5800 case 11 :
5801 if (image == null)
5802 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5803 else
5804 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5805 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5806 break;
5807 case 12 :
5808 if (image == null)
5809 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5810 else
5811 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5812 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5813 break;
5814 case 13 :
5815 if (image == null)
5816 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5817 else
5818 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5819 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5820 break;
5821 case 14 :
5822 if (image == null)
5823 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5824 else
5825 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5826 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5827 break;
5828 case 15 :
5829 if (image == null)
5830 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5831 else
5832 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5833 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5834 break;
5835 case 16 :
5836 if (image == null)
5837 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5838 else
5839 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5840 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5841 break;
5842 case 17 :
5843 if (image == null)
5844 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5845 else
5846 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5847 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5848 break;
5849 case 18 :
5850 if (image == null)
5851 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5852 else
5853 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5854 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5855 break;
5856 case 19 :
5857 if (image == null)
5858 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5859 else
5860 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5861 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5862 break;
5863 case 20 :
5864 if (image == null)
5865 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5866 else
5867 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5868 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5869 break;
5870 case 21 :
5871 if (image == null)
5872 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5873 else
5874 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5875 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5876 break;
5877 case 22 :
5878 if (image == null)
5879 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5880 else
5881 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5882 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5883 break;
5884 case 23 :
5885 if (image == null)
5886 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5887 else
5888 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5889 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5890 break;
5891 case 24 :
5892 if (image == null)
5893 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5894 else
5895 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5896 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5897 break;
5898 case 25 :
5899 if (image == null)
5900 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5901 else
5902 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5903 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5904 break;
5905 case 26 :
5906 if (image == null)
5907 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5908 else
5909 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5910 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5911 break;
5912 case 27 :
5913 if (image == null)
5914 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5915 else
5916 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5917 strictSyntaxCheck(matchedToken, DEFAULT);
5918 break;
5919 case 28 :
5920 if (image == null)
5921 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5922 else
5923 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5924 strictSyntaxCheck(matchedToken, NO_PARSE); noparseTag="comment";
5925 break;
5926 case 29 :
5927 if (image == null)
5928 image = new StringBuffer (jjstrLiteralImages[29]);
5929 else
5930 image.append(jjstrLiteralImages[29]);
5931 noparseTag = "-->"; SwitchTo(NO_PARSE);
5932 break;
5933 case 30 :
5934 if (image == null)
5935 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5936 else
5937 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5938 strictSyntaxCheck(matchedToken, NO_PARSE); noparseTag="noparse";
5939 break;
5940 case 31 :
5941 if (image == null)
5942 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5943 else
5944 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5945 strictSyntaxCheck(matchedToken, DEFAULT);
5946 break;
5947 case 32 :
5948 if (image == null)
5949 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5950 else
5951 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5952 strictSyntaxCheck(matchedToken, DEFAULT);
5953 break;
5954 case 33 :
5955 if (image == null)
5956 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5957 else
5958 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5959 strictSyntaxCheck(matchedToken, DEFAULT);
5960 break;
5961 case 34 :
5962 if (image == null)
5963 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5964 else
5965 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5966 strictSyntaxCheck(matchedToken, DEFAULT);
5967 break;
5968 case 35 :
5969 if (image == null)
5970 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5971 else
5972 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5973 strictSyntaxCheck(matchedToken, DEFAULT);
5974 break;
5975 case 36 :
5976 if (image == null)
5977 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5978 else
5979 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5980 strictSyntaxCheck(matchedToken, DEFAULT);
5981 break;
5982 case 37 :
5983 if (image == null)
5984 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5985 else
5986 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5987 strictSyntaxCheck(matchedToken, DEFAULT);
5988 break;
5989 case 38 :
5990 if (image == null)
5991 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5992 else
5993 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5994 strictSyntaxCheck(matchedToken, DEFAULT);
5995 break;
5996 case 39 :
5997 if (image == null)
5998 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5999 else
6000 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6001 strictSyntaxCheck(matchedToken, DEFAULT);
6002 break;
6003 case 40 :
6004 if (image == null)
6005 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6006 else
6007 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6008 strictSyntaxCheck(matchedToken, DEFAULT);
6009 break;
6010 case 41 :
6011 if (image == null)
6012 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6013 else
6014 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6015 strictSyntaxCheck(matchedToken, DEFAULT);
6016 break;
6017 case 42 :
6018 if (image == null)
6019 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6020 else
6021 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6022 strictSyntaxCheck(matchedToken, DEFAULT);
6023 break;
6024 case 43 :
6025 if (image == null)
6026 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6027 else
6028 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6029 strictSyntaxCheck(matchedToken, DEFAULT);
6030 break;
6031 case 44 :
6032 if (image == null)
6033 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6034 else
6035 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6036 strictSyntaxCheck(matchedToken, DEFAULT);
6037 break;
6038 case 45 :
6039 if (image == null)
6040 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6041 else
6042 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6043 strictSyntaxCheck(matchedToken, DEFAULT);
6044 break;
6045 case 46 :
6046 if (image == null)
6047 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6048 else
6049 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6050 strictSyntaxCheck(matchedToken, DEFAULT);
6051 break;
6052 case 47 :
6053 if (image == null)
6054 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6055 else
6056 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6057 strictSyntaxCheck(matchedToken, DEFAULT);
6058 break;
6059 case 48 :
6060 if (image == null)
6061 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6062 else
6063 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6064 strictSyntaxCheck(matchedToken, DEFAULT);
6065 break;
6066 case 49 :
6067 if (image == null)
6068 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6069 else
6070 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6071 strictSyntaxCheck(matchedToken, DEFAULT);
6072 break;
6073 case 50 :
6074 if (image == null)
6075 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6076 else
6077 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6078 strictSyntaxCheck(matchedToken, DEFAULT);
6079 break;
6080 case 51 :
6081 if (image == null)
6082 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6083 else
6084 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6085 strictSyntaxCheck(matchedToken, DEFAULT);
6086 break;
6087 case 52 :
6088 if (image == null)
6089 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6090 else
6091 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6092 strictSyntaxCheck(matchedToken, DEFAULT);
6093 break;
6094 case 53 :
6095 if (image == null)
6096 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6097 else
6098 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6099 strictSyntaxCheck(matchedToken, DEFAULT);
6100 break;
6101 case 54 :
6102 if (image == null)
6103 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6104 else
6105 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6106 strictSyntaxCheck(matchedToken, DEFAULT);
6107 break;
6108 case 55 :
6109 if (image == null)
6110 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6111 else
6112 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6113 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
6114 break;
6115 case 56 :
6116 if (image == null)
6117 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6118 else
6119 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6120 strictSyntaxCheck(matchedToken, DEFAULT);
6121 break;
6122 case 57 :
6123 if (image == null)
6124 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6125 else
6126 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6127 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
6128 break;
6129 case 58 :
6130 if (image == null)
6131 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6132 else
6133 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6134 strictSyntaxCheck(matchedToken, DEFAULT);
6135 break;
6136 case 59 :
6137 if (image == null)
6138 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6139 else
6140 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6141 strictSyntaxCheck(matchedToken, FM_EXPRESSION);
6142 break;
6143 case 60 :
6144 if (image == null)
6145 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6146 else
6147 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6148 strictSyntaxCheck(matchedToken, DEFAULT);
6149 break;
6150 case 61 :
6151 if (image == null)
6152 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6153 else
6154 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6155 strictSyntaxCheck(matchedToken, DEFAULT);
6156 break;
6157 case 62 :
6158 if (image == null)
6159 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6160 else
6161 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6162 strictSyntaxCheck(matchedToken, DEFAULT);
6163 break;
6164 case 65 :
6165 if (image == null)
6166 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6167 else
6168 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6169 inFTLHeader = true; SwitchTo(FM_EXPRESSION);
6170 break;
6171 case 66 :
6172 if (image == null)
6173 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6174 else
6175 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6176 eatNewline();
6177 break;
6178 case 67 :
6179 if (image == null)
6180 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6181 else
6182 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6183 if (strictEscapeSyntax) {
6184 String s = matchedToken.image;
6185 int index = s.indexOf('#');
6186 s = s.substring(index);
6187 String msg = "Unknown directive: "
6188 + s
6189 + " on line: " + matchedToken.beginLine
6190 + ", column: " + matchedToken.beginColumn +1
6191 + ", in template: " + templateName;
6192
6193 throw new TokenMgrError(msg, TokenMgrError.LEXICAL_ERROR);
6194 }
6195 break;
6196 case 111 :
6197 if (image == null)
6198 image = new StringBuffer (jjstrLiteralImages[111]);
6199 else
6200 image.append(jjstrLiteralImages[111]);
6201 ++parenthesisNesting;
6202 if (parenthesisNesting == 1)
6203 SwitchTo(IN_PAREN);
6204 break;
6205 case 112 :
6206 if (image == null)
6207 image = new StringBuffer (jjstrLiteralImages[112]);
6208 else
6209 image.append(jjstrLiteralImages[112]);
6210 --parenthesisNesting;
6211 if (parenthesisNesting == 0)
6212 SwitchTo(FM_EXPRESSION);
6213 break;
6214 case 113 :
6215 if (image == null)
6216 image = new StringBuffer (jjstrLiteralImages[113]);
6217 else
6218 image.append(jjstrLiteralImages[113]);
6219 ++hashLiteralNesting;
6220 break;
6221 case 114 :
6222 if (image == null)
6223 image = new StringBuffer (jjstrLiteralImages[114]);
6224 else
6225 image.append(jjstrLiteralImages[114]);
6226 if (hashLiteralNesting == 0)
6227 SwitchTo(DEFAULT);
6228 else
6229 --hashLiteralNesting;
6230 break;
6231 case 121 :
6232 if (image == null)
6233 image = new StringBuffer (jjstrLiteralImages[121]);
6234 else
6235 image.append(jjstrLiteralImages[121]);
6236 if (inFTLHeader) eatNewline(); inFTLHeader = false; SwitchTo(DEFAULT);
6237 break;
6238 case 122 :
6239 if (image == null)
6240 image = new StringBuffer (jjstrLiteralImages[122]);
6241 else
6242 image.append(jjstrLiteralImages[122]);
6243 if (inFTLHeader) eatNewline(); inFTLHeader = false; SwitchTo(DEFAULT);
6244 break;
6245 case 126 :
6246 if (image == null)
6247 image = new StringBuffer (jjstrLiteralImages[126]);
6248 else
6249 image.append(jjstrLiteralImages[126]);
6250 if (noparseTag.equals("-->"))
6251 SwitchTo(DEFAULT);
6252 break;
6253 case 127 :
6254 if (image == null)
6255 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6256 else
6257 image.append(new String (input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
6258 StringTokenizer st = new StringTokenizer(image.toString(),
6259 " \t\n\r<>/#",
6260 false);
6261 if (st.nextToken().equals(noparseTag)) {
6262 SwitchTo(DEFAULT);
6263 }
6264 break;
6265 default :
6266 break;
6267 }
6268}
6269}
6270 |
Popular Tags |
Java API By Example, From Geeks To Geeks.