001 /* Generated By:JavaCC: Do not edit this line. AnimTimeParserTokenManager.java */
002 package com.kitfox.svg.animation.parser;
003 import java.util.*;
004 import java.io.*;
005 import com.kitfox.svg.animation.*;
006
007 /** Token Manager. */
008 public class AnimTimeParserTokenManager implements AnimTimeParserConstants
009 {
010
011 /** Debug output. */
012 public java.io.PrintStream debugStream = System.out;
013 /** Set debug output. */
014 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
015 private final int jjStopStringLiteralDfa_0(int pos, long active0)
016 {
017 switch (pos)
018 {
019 case 0:
020 if ((active0 & 0x30000L) != 0L)
021 return 6;
022 if ((active0 & 0x80000L) != 0L)
023 return 2;
024 if ((active0 & 0x1400L) != 0L)
025 {
026 jjmatchedKind = 14;
027 return 11;
028 }
029 if ((active0 & 0x800L) != 0L)
030 {
031 jjmatchedKind = 14;
032 return 13;
033 }
034 return -1;
035 case 1:
036 if ((active0 & 0x1c00L) != 0L)
037 {
038 jjmatchedKind = 14;
039 jjmatchedPos = 1;
040 return 11;
041 }
042 return -1;
043 case 2:
044 if ((active0 & 0x1c00L) != 0L)
045 {
046 jjmatchedKind = 14;
047 jjmatchedPos = 2;
048 return 11;
049 }
050 return -1;
051 case 3:
052 if ((active0 & 0x1c00L) != 0L)
053 {
054 jjmatchedKind = 14;
055 jjmatchedPos = 3;
056 return 11;
057 }
058 return -1;
059 case 4:
060 if ((active0 & 0x1c00L) != 0L)
061 {
062 jjmatchedKind = 14;
063 jjmatchedPos = 4;
064 return 11;
065 }
066 return -1;
067 case 5:
068 if ((active0 & 0x1c00L) != 0L)
069 {
070 jjmatchedKind = 14;
071 jjmatchedPos = 5;
072 return 11;
073 }
074 return -1;
075 case 6:
076 if ((active0 & 0x1c00L) != 0L)
077 {
078 jjmatchedKind = 14;
079 jjmatchedPos = 6;
080 return 11;
081 }
082 return -1;
083 case 7:
084 if ((active0 & 0x1c00L) != 0L)
085 {
086 jjmatchedKind = 14;
087 jjmatchedPos = 7;
088 return 11;
089 }
090 return -1;
091 case 8:
092 if ((active0 & 0x800L) != 0L)
093 return 11;
094 if ((active0 & 0x1400L) != 0L)
095 {
096 jjmatchedKind = 14;
097 jjmatchedPos = 8;
098 return 11;
099 }
100 return -1;
101 case 9:
102 if ((active0 & 0x1000L) != 0L)
103 {
104 jjmatchedKind = 14;
105 jjmatchedPos = 9;
106 return 11;
107 }
108 if ((active0 & 0x400L) != 0L)
109 return 11;
110 return -1;
111 case 10:
112 if ((active0 & 0x1000L) != 0L)
113 {
114 jjmatchedKind = 14;
115 jjmatchedPos = 10;
116 return 11;
117 }
118 return -1;
119 case 11:
120 if ((active0 & 0x1000L) != 0L)
121 {
122 jjmatchedKind = 14;
123 jjmatchedPos = 11;
124 return 11;
125 }
126 return -1;
127 default :
128 return -1;
129 }
130 }
131 private final int jjStartNfa_0(int pos, long active0)
132 {
133 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
134 }
135 private int jjStopAtPos(int pos, int kind)
136 {
137 jjmatchedKind = kind;
138 jjmatchedPos = pos;
139 return pos + 1;
140 }
141 private int jjMoveStringLiteralDfa0_0()
142 {
143 switch(curChar)
144 {
145 case 40:
146 return jjStopAtPos(0, 20);
147 case 41:
148 return jjStopAtPos(0, 21);
149 case 43:
150 return jjStartNfaWithStates_0(0, 16, 6);
151 case 45:
152 return jjStartNfaWithStates_0(0, 17, 6);
153 case 46:
154 return jjStartNfaWithStates_0(0, 19, 2);
155 case 58:
156 return jjStopAtPos(0, 18);
157 case 59:
158 return jjStopAtPos(0, 15);
159 case 105:
160 return jjMoveStringLiteralDfa1_0(0x400L);
161 case 109:
162 return jjMoveStringLiteralDfa1_0(0x800L);
163 case 119:
164 return jjMoveStringLiteralDfa1_0(0x1000L);
165 default :
166 return jjMoveNfa_0(0, 0);
167 }
168 }
169 private int jjMoveStringLiteralDfa1_0(long active0)
170 {
171 try { curChar = input_stream.readChar(); }
172 catch(java.io.IOException e) {
173 jjStopStringLiteralDfa_0(0, active0);
174 return 1;
175 }
176 switch(curChar)
177 {
178 case 104:
179 return jjMoveStringLiteralDfa2_0(active0, 0x1000L);
180 case 110:
181 return jjMoveStringLiteralDfa2_0(active0, 0x400L);
182 case 111:
183 return jjMoveStringLiteralDfa2_0(active0, 0x800L);
184 default :
185 break;
186 }
187 return jjStartNfa_0(0, active0);
188 }
189 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
190 {
191 if (((active0 &= old0)) == 0L)
192 return jjStartNfa_0(0, old0);
193 try { curChar = input_stream.readChar(); }
194 catch(java.io.IOException e) {
195 jjStopStringLiteralDfa_0(1, active0);
196 return 2;
197 }
198 switch(curChar)
199 {
200 case 100:
201 return jjMoveStringLiteralDfa3_0(active0, 0x400L);
202 case 101:
203 return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
204 case 117:
205 return jjMoveStringLiteralDfa3_0(active0, 0x800L);
206 default :
207 break;
208 }
209 return jjStartNfa_0(1, active0);
210 }
211 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
212 {
213 if (((active0 &= old0)) == 0L)
214 return jjStartNfa_0(1, old0);
215 try { curChar = input_stream.readChar(); }
216 catch(java.io.IOException e) {
217 jjStopStringLiteralDfa_0(2, active0);
218 return 3;
219 }
220 switch(curChar)
221 {
222 case 101:
223 return jjMoveStringLiteralDfa4_0(active0, 0x400L);
224 case 110:
225 return jjMoveStringLiteralDfa4_0(active0, 0x1000L);
226 case 115:
227 return jjMoveStringLiteralDfa4_0(active0, 0x800L);
228 default :
229 break;
230 }
231 return jjStartNfa_0(2, active0);
232 }
233 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
234 {
235 if (((active0 &= old0)) == 0L)
236 return jjStartNfa_0(2, old0);
237 try { curChar = input_stream.readChar(); }
238 catch(java.io.IOException e) {
239 jjStopStringLiteralDfa_0(3, active0);
240 return 4;
241 }
242 switch(curChar)
243 {
244 case 78:
245 return jjMoveStringLiteralDfa5_0(active0, 0x1000L);
246 case 101:
247 return jjMoveStringLiteralDfa5_0(active0, 0x800L);
248 case 102:
249 return jjMoveStringLiteralDfa5_0(active0, 0x400L);
250 default :
251 break;
252 }
253 return jjStartNfa_0(3, active0);
254 }
255 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
256 {
257 if (((active0 &= old0)) == 0L)
258 return jjStartNfa_0(3, old0);
259 try { curChar = input_stream.readChar(); }
260 catch(java.io.IOException e) {
261 jjStopStringLiteralDfa_0(4, active0);
262 return 5;
263 }
264 switch(curChar)
265 {
266 case 105:
267 return jjMoveStringLiteralDfa6_0(active0, 0x400L);
268 case 111:
269 return jjMoveStringLiteralDfa6_0(active0, 0x1800L);
270 default :
271 break;
272 }
273 return jjStartNfa_0(4, active0);
274 }
275 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
276 {
277 if (((active0 &= old0)) == 0L)
278 return jjStartNfa_0(4, old0);
279 try { curChar = input_stream.readChar(); }
280 catch(java.io.IOException e) {
281 jjStopStringLiteralDfa_0(5, active0);
282 return 6;
283 }
284 switch(curChar)
285 {
286 case 110:
287 return jjMoveStringLiteralDfa7_0(active0, 0x400L);
288 case 116:
289 return jjMoveStringLiteralDfa7_0(active0, 0x1000L);
290 case 118:
291 return jjMoveStringLiteralDfa7_0(active0, 0x800L);
292 default :
293 break;
294 }
295 return jjStartNfa_0(5, active0);
296 }
297 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
298 {
299 if (((active0 &= old0)) == 0L)
300 return jjStartNfa_0(5, old0);
301 try { curChar = input_stream.readChar(); }
302 catch(java.io.IOException e) {
303 jjStopStringLiteralDfa_0(6, active0);
304 return 7;
305 }
306 switch(curChar)
307 {
308 case 65:
309 return jjMoveStringLiteralDfa8_0(active0, 0x1000L);
310 case 101:
311 return jjMoveStringLiteralDfa8_0(active0, 0x800L);
312 case 105:
313 return jjMoveStringLiteralDfa8_0(active0, 0x400L);
314 default :
315 break;
316 }
317 return jjStartNfa_0(6, active0);
318 }
319 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
320 {
321 if (((active0 &= old0)) == 0L)
322 return jjStartNfa_0(6, old0);
323 try { curChar = input_stream.readChar(); }
324 catch(java.io.IOException e) {
325 jjStopStringLiteralDfa_0(7, active0);
326 return 8;
327 }
328 switch(curChar)
329 {
330 case 99:
331 return jjMoveStringLiteralDfa9_0(active0, 0x1000L);
332 case 114:
333 if ((active0 & 0x800L) != 0L)
334 return jjStartNfaWithStates_0(8, 11, 11);
335 break;
336 case 116:
337 return jjMoveStringLiteralDfa9_0(active0, 0x400L);
338 default :
339 break;
340 }
341 return jjStartNfa_0(7, active0);
342 }
343 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
344 {
345 if (((active0 &= old0)) == 0L)
346 return jjStartNfa_0(7, old0);
347 try { curChar = input_stream.readChar(); }
348 catch(java.io.IOException e) {
349 jjStopStringLiteralDfa_0(8, active0);
350 return 9;
351 }
352 switch(curChar)
353 {
354 case 101:
355 if ((active0 & 0x400L) != 0L)
356 return jjStartNfaWithStates_0(9, 10, 11);
357 break;
358 case 116:
359 return jjMoveStringLiteralDfa10_0(active0, 0x1000L);
360 default :
361 break;
362 }
363 return jjStartNfa_0(8, active0);
364 }
365 private int jjMoveStringLiteralDfa10_0(long old0, long active0)
366 {
367 if (((active0 &= old0)) == 0L)
368 return jjStartNfa_0(8, old0);
369 try { curChar = input_stream.readChar(); }
370 catch(java.io.IOException e) {
371 jjStopStringLiteralDfa_0(9, active0);
372 return 10;
373 }
374 switch(curChar)
375 {
376 case 105:
377 return jjMoveStringLiteralDfa11_0(active0, 0x1000L);
378 default :
379 break;
380 }
381 return jjStartNfa_0(9, active0);
382 }
383 private int jjMoveStringLiteralDfa11_0(long old0, long active0)
384 {
385 if (((active0 &= old0)) == 0L)
386 return jjStartNfa_0(9, old0);
387 try { curChar = input_stream.readChar(); }
388 catch(java.io.IOException e) {
389 jjStopStringLiteralDfa_0(10, active0);
390 return 11;
391 }
392 switch(curChar)
393 {
394 case 118:
395 return jjMoveStringLiteralDfa12_0(active0, 0x1000L);
396 default :
397 break;
398 }
399 return jjStartNfa_0(10, active0);
400 }
401 private int jjMoveStringLiteralDfa12_0(long old0, long active0)
402 {
403 if (((active0 &= old0)) == 0L)
404 return jjStartNfa_0(10, old0);
405 try { curChar = input_stream.readChar(); }
406 catch(java.io.IOException e) {
407 jjStopStringLiteralDfa_0(11, active0);
408 return 12;
409 }
410 switch(curChar)
411 {
412 case 101:
413 if ((active0 & 0x1000L) != 0L)
414 return jjStartNfaWithStates_0(12, 12, 11);
415 break;
416 default :
417 break;
418 }
419 return jjStartNfa_0(11, active0);
420 }
421 private int jjStartNfaWithStates_0(int pos, int kind, int state)
422 {
423 jjmatchedKind = kind;
424 jjmatchedPos = pos;
425 try { curChar = input_stream.readChar(); }
426 catch(java.io.IOException e) { return pos + 1; }
427 return jjMoveNfa_0(state, pos + 1);
428 }
429 private int jjMoveNfa_0(int startState, int curPos)
430 {
431 int startsAt = 0;
432 jjnewStateCnt = 18;
433 int i = 1;
434 jjstateSet[0] = startState;
435 int kind = 0x7fffffff;
436 for (;;)
437 {
438 if (++jjround == 0x7fffffff)
439 ReInitRounds();
440 if (curChar < 64)
441 {
442 long l = 1L << curChar;
443 do
444 {
445 switch(jjstateSet[--i])
446 {
447 case 6:
448 if ((0x3ff000000000000L & l) != 0L)
449 {
450 if (kind > 9)
451 kind = 9;
452 jjCheckNAddStates(0, 3);
453 }
454 else if (curChar == 46)
455 jjCheckNAdd(2);
456 break;
457 case 13:
458 case 11:
459 if ((0x3ff200000000000L & l) == 0L)
460 break;
461 if (kind > 14)
462 kind = 14;
463 jjCheckNAdd(11);
464 break;
465 case 0:
466 if ((0x3ff000000000000L & l) != 0L)
467 {
468 if (kind > 8)
469 kind = 8;
470 jjCheckNAddStates(4, 8);
471 }
472 else if ((0x280000000000L & l) != 0L)
473 jjCheckNAddTwoStates(1, 6);
474 else if (curChar == 46)
475 jjCheckNAdd(2);
476 break;
477 case 1:
478 if (curChar == 46)
479 jjCheckNAdd(2);
480 break;
481 case 2:
482 if ((0x3ff000000000000L & l) == 0L)
483 break;
484 if (kind > 9)
485 kind = 9;
486 jjCheckNAddTwoStates(2, 3);
487 break;
488 case 4:
489 if ((0x280000000000L & l) != 0L)
490 jjCheckNAdd(5);
491 break;
492 case 5:
493 if ((0x3ff000000000000L & l) == 0L)
494 break;
495 if (kind > 9)
496 kind = 9;
497 jjCheckNAdd(5);
498 break;
499 case 7:
500 if ((0x3ff000000000000L & l) != 0L)
501 jjCheckNAddTwoStates(7, 1);
502 break;
503 case 8:
504 if ((0x3ff000000000000L & l) == 0L)
505 break;
506 if (kind > 9)
507 kind = 9;
508 jjCheckNAddTwoStates(8, 3);
509 break;
510 case 16:
511 if ((0x3ff000000000000L & l) == 0L)
512 break;
513 if (kind > 8)
514 kind = 8;
515 jjCheckNAddStates(4, 8);
516 break;
517 case 17:
518 if ((0x3ff000000000000L & l) == 0L)
519 break;
520 if (kind > 8)
521 kind = 8;
522 jjCheckNAdd(17);
523 break;
524 default : break;
525 }
526 } while(i != startsAt);
527 }
528 else if (curChar < 128)
529 {
530 long l = 1L << (curChar & 077);
531 do
532 {
533 switch(jjstateSet[--i])
534 {
535 case 13:
536 if ((0x7fffffe87fffffeL & l) != 0L)
537 {
538 if (kind > 14)
539 kind = 14;
540 jjCheckNAdd(11);
541 }
542 if (curChar == 105)
543 jjstateSet[jjnewStateCnt++] = 14;
544 else if (curChar == 115)
545 {
546 if (kind > 13)
547 kind = 13;
548 }
549 break;
550 case 0:
551 if ((0x7fffffe07fffffeL & l) != 0L)
552 {
553 if (kind > 14)
554 kind = 14;
555 jjCheckNAdd(11);
556 }
557 if ((0x8010000000000L & l) != 0L)
558 {
559 if (kind > 13)
560 kind = 13;
561 }
562 else if (curChar == 109)
563 jjAddStates(9, 10);
564 break;
565 case 3:
566 if ((0x2000000020L & l) != 0L)
567 jjAddStates(11, 12);
568 break;
569 case 9:
570 if ((0x8010000000000L & l) != 0L && kind > 13)
571 kind = 13;
572 break;
573 case 10:
574 if ((0x7fffffe07fffffeL & l) == 0L)
575 break;
576 if (kind > 14)
577 kind = 14;
578 jjCheckNAdd(11);
579 break;
580 case 11:
581 if ((0x7fffffe87fffffeL & l) == 0L)
582 break;
583 if (kind > 14)
584 kind = 14;
585 jjCheckNAdd(11);
586 break;
587 case 12:
588 if (curChar == 109)
589 jjAddStates(9, 10);
590 break;
591 case 14:
592 if (curChar == 110 && kind > 13)
593 kind = 13;
594 break;
595 case 15:
596 if (curChar == 105)
597 jjstateSet[jjnewStateCnt++] = 14;
598 break;
599 default : break;
600 }
601 } while(i != startsAt);
602 }
603 else
604 {
605 int i2 = (curChar & 0xff) >> 6;
606 long l2 = 1L << (curChar & 077);
607 do
608 {
609 switch(jjstateSet[--i])
610 {
611 default : break;
612 }
613 } while(i != startsAt);
614 }
615 if (kind != 0x7fffffff)
616 {
617 jjmatchedKind = kind;
618 jjmatchedPos = curPos;
619 kind = 0x7fffffff;
620 }
621 ++curPos;
622 if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
623 return curPos;
624 try { curChar = input_stream.readChar(); }
625 catch(java.io.IOException e) { return curPos; }
626 }
627 }
628 static final int[] jjnextStates = {
629 7, 1, 8, 3, 17, 7, 1, 8, 3, 13, 15, 4, 5,
630 };
631
632 /** Token literal values. */
633 public static final String[] jjstrLiteralImages = {
634 "", null, null, null, null, null, null, null, null, null,
635 "\151\156\144\145\146\151\156\151\164\145", "\155\157\165\163\145\157\166\145\162",
636 "\167\150\145\156\116\157\164\101\143\164\151\166\145", null, null, "\73", "\53", "\55", "\72", "\56", "\50", "\51", };
637
638 /** Lexer state names. */
639 public static final String[] lexStateNames = {
640 "DEFAULT",
641 };
642 static final long[] jjtoToken = {
643 0x3fff01L,
644 };
645 static final long[] jjtoSkip = {
646 0x3eL,
647 };
648 protected SimpleCharStream input_stream;
649 private final int[] jjrounds = new int[18];
650 private final int[] jjstateSet = new int[36];
651 protected char curChar;
652 /** Constructor. */
653 public AnimTimeParserTokenManager(SimpleCharStream stream){
654 if (SimpleCharStream.staticFlag)
655 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
656 input_stream = stream;
657 }
658
659 /** Constructor. */
660 public AnimTimeParserTokenManager(SimpleCharStream stream, int lexState){
661 this(stream);
662 SwitchTo(lexState);
663 }
664
665 /** Reinitialise parser. */
666 public void ReInit(SimpleCharStream stream)
667 {
668 jjmatchedPos = jjnewStateCnt = 0;
669 curLexState = defaultLexState;
670 input_stream = stream;
671 ReInitRounds();
672 }
673 private void ReInitRounds()
674 {
675 int i;
676 jjround = 0x80000001;
677 for (i = 18; i-- > 0;)
678 jjrounds[i] = 0x80000000;
679 }
680
681 /** Reinitialise parser. */
682 public void ReInit(SimpleCharStream stream, int lexState)
683 {
684 ReInit(stream);
685 SwitchTo(lexState);
686 }
687
688 /** Switch to specified lex state. */
689 public void SwitchTo(int lexState)
690 {
691 if (lexState >= 1 || lexState < 0)
692 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
693 else
694 curLexState = lexState;
695 }
696
697 protected Token jjFillToken()
698 {
699 final Token t;
700 final String curTokenImage;
701 final int beginLine;
702 final int endLine;
703 final int beginColumn;
704 final int endColumn;
705 String im = jjstrLiteralImages[jjmatchedKind];
706 curTokenImage = (im == null) ? input_stream.GetImage() : im;
707 beginLine = input_stream.getBeginLine();
708 beginColumn = input_stream.getBeginColumn();
709 endLine = input_stream.getEndLine();
710 endColumn = input_stream.getEndColumn();
711 t = Token.newToken(jjmatchedKind, curTokenImage);
712
713 t.beginLine = beginLine;
714 t.endLine = endLine;
715 t.beginColumn = beginColumn;
716 t.endColumn = endColumn;
717
718 return t;
719 }
720
721 int curLexState = 0;
722 int defaultLexState = 0;
723 int jjnewStateCnt;
724 int jjround;
725 int jjmatchedPos;
726 int jjmatchedKind;
727
728 /** Get the next Token. */
729 public Token getNextToken()
730 {
731 Token matchedToken;
732 int curPos = 0;
733
734 EOFLoop :
735 for (;;)
736 {
737 try
738 {
739 curChar = input_stream.BeginToken();
740 }
741 catch(java.io.IOException e)
742 {
743 jjmatchedKind = 0;
744 matchedToken = jjFillToken();
745 return matchedToken;
746 }
747
748 try { input_stream.backup(0);
749 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
750 curChar = input_stream.BeginToken();
751 }
752 catch (java.io.IOException e1) { continue EOFLoop; }
753 jjmatchedKind = 0x7fffffff;
754 jjmatchedPos = 0;
755 curPos = jjMoveStringLiteralDfa0_0();
756 if (jjmatchedKind != 0x7fffffff)
757 {
758 if (jjmatchedPos + 1 < curPos)
759 input_stream.backup(curPos - jjmatchedPos - 1);
760 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
761 {
762 matchedToken = jjFillToken();
763 return matchedToken;
764 }
765 else
766 {
767 continue EOFLoop;
768 }
769 }
770 int error_line = input_stream.getEndLine();
771 int error_column = input_stream.getEndColumn();
772 String error_after = null;
773 boolean EOFSeen = false;
774 try { input_stream.readChar(); input_stream.backup(1); }
775 catch (java.io.IOException e1) {
776 EOFSeen = true;
777 error_after = curPos <= 1 ? "" : input_stream.GetImage();
778 if (curChar == '\n' || curChar == '\r') {
779 error_line++;
780 error_column = 0;
781 }
782 else
783 error_column++;
784 }
785 if (!EOFSeen) {
786 input_stream.backup(1);
787 error_after = curPos <= 1 ? "" : input_stream.GetImage();
788 }
789 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
790 }
791 }
792
793 private void jjCheckNAdd(int state)
794 {
795 if (jjrounds[state] != jjround)
796 {
797 jjstateSet[jjnewStateCnt++] = state;
798 jjrounds[state] = jjround;
799 }
800 }
801 private void jjAddStates(int start, int end)
802 {
803 do {
804 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
805 } while (start++ != end);
806 }
807 private void jjCheckNAddTwoStates(int state1, int state2)
808 {
809 jjCheckNAdd(state1);
810 jjCheckNAdd(state2);
811 }
812
813 private void jjCheckNAddStates(int start, int end)
814 {
815 do {
816 jjCheckNAdd(jjnextStates[start]);
817 } while (start++ != end);
818 }
819
820 }