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