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