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