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