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