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