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