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