001    /* Generated By:JavaCC: Do not edit this line. GeneratedFormulaParser.java */
002    package org.jfree.formula.parser;
003    
004    import java.math.BigDecimal;
005    import java.util.ArrayList;
006    
007    import org.jfree.formula.lvalues.ContextLookup;
008    import org.jfree.formula.lvalues.FormulaFunction;
009    import org.jfree.formula.lvalues.LValue;
010    import org.jfree.formula.lvalues.PostfixTerm;
011    import org.jfree.formula.lvalues.PrefixTerm;
012    import org.jfree.formula.lvalues.StaticValue;
013    import org.jfree.formula.lvalues.Term;
014    import org.jfree.formula.lvalues.DefaultDataTable;
015    import org.jfree.formula.operators.InfixOperator;
016    import org.jfree.formula.operators.OperatorFactory;
017    import org.jfree.formula.operators.PostfixOperator;
018    import org.jfree.formula.operators.PrefixOperator;
019    import org.jfree.formula.typing.coretypes.NumberType;
020    import org.jfree.formula.typing.coretypes.TextType;
021    
022    public abstract class GeneratedFormulaParser implements GeneratedFormulaParserConstants {
023    
024      protected GeneratedFormulaParser ()
025      {
026      }
027    
028      protected abstract OperatorFactory getOperatorFactory();
029    
030      final public LValue getExpression() throws ParseException {
031      LValue retval = null;
032      Term term = null;
033        retval = getLValue();
034        switch (jj_nt.kind) {
035        case PLUS:
036        case MINUS:
037        case MULT:
038        case DIV:
039        case POW:
040        case EQUALS:
041        case NOT_EQUALS:
042        case LT_EQUALS:
043        case GT_EQUALS:
044        case LT:
045        case GT:
046        case CONCAT:
047          term = startTail(new Term(retval));
048          label_1:
049          while (true) {
050            switch (jj_nt.kind) {
051            case PLUS:
052            case MINUS:
053            case MULT:
054            case DIV:
055            case POW:
056            case EQUALS:
057            case NOT_EQUALS:
058            case LT_EQUALS:
059            case GT_EQUALS:
060            case LT:
061            case GT:
062            case CONCAT:
063              ;
064              break;
065            default:
066              jj_la1[0] = jj_gen;
067              break label_1;
068            }
069            term = startTail(term);
070          }
071          break;
072        default:
073          jj_la1[1] = jj_gen;
074          ;
075        }
076        if (term != null)
077        {
078          {if (true) return term;}
079        }
080        {if (true) return retval;}
081        throw new Error("Missing return statement in function");
082      }
083    
084      final public Term startTail(LValue retval) throws ParseException {
085      LValue val = null;
086      InfixOperator op = null;
087      Term ex = null;
088        op = getInfixOperator();
089        val = getLValue();
090          if (retval instanceof Term)
091          {
092            ex = (Term) retval;
093          }
094          else
095          {
096            ex = new Term (retval);
097          }
098          ex.add (op, val);
099    
100          {if (true) return ex;}
101        throw new Error("Missing return statement in function");
102      }
103    
104      final public LValue getLValue() throws ParseException {
105      Token value = null;
106      LValue retval = null;
107      PrefixOperator prefixOp = null;
108      PostfixOperator postfixOp = null;
109        switch (jj_nt.kind) {
110        case PLUS:
111        case MINUS:
112          prefixOp = getPrefixOperator();
113          break;
114        default:
115          jj_la1[2] = jj_gen;
116          ;
117        }
118        switch (jj_nt.kind) {
119        case COLUMN_LOOKUP:
120          value = jj_consume_token(COLUMN_LOOKUP);
121                                    retval = new ContextLookup (ParserTools.stripQuote(value.image));
122          break;
123        case STRING_LITERAL:
124          value = jj_consume_token(STRING_LITERAL);
125                                     retval = new StaticValue (ParserTools.stripQuote(value.image), TextType.TYPE);
126          break;
127        case UNSIGNED_NUMERIC_LITERAL:
128          value = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
129                                               retval = new StaticValue (new BigDecimal (value.image), NumberType.GENERIC_NUMBER);
130          break;
131        case UNSIGNED_INTEGER:
132          value = jj_consume_token(UNSIGNED_INTEGER);
133                                       retval = new StaticValue (new BigDecimal (value.image), NumberType.GENERIC_NUMBER);
134          break;
135        case NULL:
136          jj_consume_token(NULL);
137                   retval = new StaticValue (null);
138          break;
139        case L_BRACE:
140          jj_consume_token(L_BRACE);
141          retval = parseArray();
142          jj_consume_token(R_BRACE);
143          break;
144        case IDENTIFIER:
145          value = jj_consume_token(IDENTIFIER);
146          jj_consume_token(L_PAREN);
147                                           retval = parseFunction(value.image);
148          jj_consume_token(R_PAREN);
149          break;
150        case L_PAREN:
151          jj_consume_token(L_PAREN);
152                      retval = getExpression ();
153          jj_consume_token(R_PAREN);
154          if (retval instanceof Term == false)
155          {
156            retval = new Term (retval);
157          }
158          break;
159        default:
160          jj_la1[3] = jj_gen;
161          jj_consume_token(-1);
162          throw new ParseException();
163        }
164        switch (jj_nt.kind) {
165        case PERCENT:
166          postfixOp = getPostfixOperator();
167          break;
168        default:
169          jj_la1[4] = jj_gen;
170          ;
171        }
172        if (postfixOp != null)
173        {
174          retval = new PostfixTerm(retval, postfixOp);
175        }
176        if (prefixOp != null)
177        {
178          retval = new PrefixTerm(prefixOp, retval);
179        }
180        {if (true) return retval;}
181        throw new Error("Missing return statement in function");
182      }
183    
184      final public LValue parseArray() throws ParseException {
185            ArrayList rows = new ArrayList();
186            LValue[] row = null;
187        row = parseRow();
188                            rows.add(row);
189        label_2:
190        while (true) {
191          switch (jj_nt.kind) {
192          case PIPE:
193            ;
194            break;
195          default:
196            jj_la1[5] = jj_gen;
197            break label_2;
198          }
199          jj_consume_token(PIPE);
200          row = parseRow();
201                    // should we check here for column count equality to the first row column count?
202                    // or do we give this responsability to a DefaultDataTable constructor?
203                            rows.add(row);
204        }
205                    LValue[][] table = (LValue[][])rows.toArray(new LValue[rows.size()][]);
206                    {if (true) return new DefaultDataTable(table);}
207        throw new Error("Missing return statement in function");
208      }
209    
210      final public LValue[] parseRow() throws ParseException {
211            ArrayList cols = new ArrayList();;
212            LValue column = null;
213        column = getExpression();
214            cols.add(column);
215        label_3:
216        while (true) {
217          switch (jj_nt.kind) {
218          case SEMICOLON:
219            ;
220            break;
221          default:
222            jj_la1[6] = jj_gen;
223            break label_3;
224          }
225          jj_consume_token(SEMICOLON);
226          column = getExpression();
227               cols.add(column);
228        }
229                    {if (true) return (LValue[]) cols.toArray(new LValue[cols.size()]);}
230        throw new Error("Missing return statement in function");
231      }
232    
233      final public LValue parseFunction(String name) throws ParseException {
234       ArrayList params = new ArrayList();
235       LValue parameter = null;
236        switch (jj_nt.kind) {
237        case UNSIGNED_INTEGER:
238        case SEMICOLON:
239        case L_PAREN:
240        case L_BRACE:
241        case PLUS:
242        case MINUS:
243        case IDENTIFIER:
244        case COLUMN_LOOKUP:
245        case STRING_LITERAL:
246        case UNSIGNED_NUMERIC_LITERAL:
247        case NULL:
248          switch (jj_nt.kind) {
249          case SEMICOLON:
250            jj_consume_token(SEMICOLON);
251               params.add(new StaticValue(null));
252            break;
253          case UNSIGNED_INTEGER:
254          case L_PAREN:
255          case L_BRACE:
256          case PLUS:
257          case MINUS:
258          case IDENTIFIER:
259          case COLUMN_LOOKUP:
260          case STRING_LITERAL:
261          case UNSIGNED_NUMERIC_LITERAL:
262          case NULL:
263            parameter = getExpression();
264               params.add(parameter);
265            break;
266          default:
267            jj_la1[7] = jj_gen;
268            jj_consume_token(-1);
269            throw new ParseException();
270          }
271          label_4:
272          while (true) {
273            switch (jj_nt.kind) {
274            case SEMICOLON:
275              ;
276              break;
277            default:
278              jj_la1[8] = jj_gen;
279              break label_4;
280            }
281            jj_consume_token(SEMICOLON);
282            switch (jj_nt.kind) {
283            case UNSIGNED_INTEGER:
284            case L_PAREN:
285            case L_BRACE:
286            case PLUS:
287            case MINUS:
288            case IDENTIFIER:
289            case COLUMN_LOOKUP:
290            case STRING_LITERAL:
291            case UNSIGNED_NUMERIC_LITERAL:
292            case NULL:
293              parameter = getExpression();
294               params.add(parameter);
295              break;
296            default:
297              jj_la1[9] = jj_gen;
298              ;
299            }
300          }
301          break;
302        default:
303          jj_la1[10] = jj_gen;
304          ;
305        }
306         if (params == null)
307         {
308           {if (true) return new FormulaFunction(name, new LValue[0]);}
309         }
310    
311         LValue[] paramVals = (LValue[]) params.toArray(new LValue[params.size()]);
312         {if (true) return new FormulaFunction(name, paramVals);}
313        throw new Error("Missing return statement in function");
314      }
315    
316      final public PrefixOperator getPrefixOperator() throws ParseException {
317      Token value = null;
318        switch (jj_nt.kind) {
319        case PLUS:
320          value = jj_consume_token(PLUS);
321          break;
322        case MINUS:
323          value = jj_consume_token(MINUS);
324          break;
325        default:
326          jj_la1[11] = jj_gen;
327          jj_consume_token(-1);
328          throw new ParseException();
329        }
330         {if (true) return getOperatorFactory().createPrefixOperator(value.image);}
331        throw new Error("Missing return statement in function");
332      }
333    
334      final public PostfixOperator getPostfixOperator() throws ParseException {
335      Token value = null;
336        value = jj_consume_token(PERCENT);
337         {if (true) return getOperatorFactory().createPostfixOperator(value.image);}
338        throw new Error("Missing return statement in function");
339      }
340    
341      final public InfixOperator getInfixOperator() throws ParseException {
342      InfixOperator op = null;
343      Token value = null;
344        switch (jj_nt.kind) {
345        case PLUS:
346          value = jj_consume_token(PLUS);
347          break;
348        case MINUS:
349          value = jj_consume_token(MINUS);
350          break;
351        case MULT:
352          value = jj_consume_token(MULT);
353          break;
354        case DIV:
355          value = jj_consume_token(DIV);
356          break;
357        case POW:
358          value = jj_consume_token(POW);
359          break;
360        case EQUALS:
361          value = jj_consume_token(EQUALS);
362          break;
363        case NOT_EQUALS:
364          value = jj_consume_token(NOT_EQUALS);
365          break;
366        case LT_EQUALS:
367          value = jj_consume_token(LT_EQUALS);
368          break;
369        case GT_EQUALS:
370          value = jj_consume_token(GT_EQUALS);
371          break;
372        case LT:
373          value = jj_consume_token(LT);
374          break;
375        case GT:
376          value = jj_consume_token(GT);
377          break;
378        case CONCAT:
379          value = jj_consume_token(CONCAT);
380          break;
381        default:
382          jj_la1[12] = jj_gen;
383          jj_consume_token(-1);
384          throw new ParseException();
385        }
386        {if (true) return getOperatorFactory().createInfixOperator(value.image);}
387        throw new Error("Missing return statement in function");
388      }
389    
390      /** Generated Token Manager. */
391      public GeneratedFormulaParserTokenManager token_source;
392      JavaCharStream jj_input_stream;
393      /** Current token. */
394      public Token token;
395      /** Next token. */
396      public Token jj_nt;
397      private int jj_gen;
398      final private int[] jj_la1 = new int[13];
399      static private int[] jj_la1_0;
400      static private int[] jj_la1_1;
401      static {
402          jj_la1_init_0();
403          jj_la1_init_1();
404       }
405       private static void jj_la1_init_0() {
406          jj_la1_0 = new int[] {0xf8000000,0xf8000000,0x18000000,0x1080100,0x0,0x4000000,0x40000,0x190c0100,0x40000,0x19080100,0x190c0100,0x18000000,0xf8000000,};
407       }
408       private static void jj_la1_init_1() {
409          jj_la1_1 = new int[] {0x7f,0x7f,0x0,0x10f00,0x80,0x0,0x0,0x10f00,0x0,0x10f00,0x10f00,0x0,0x7f,};
410       }
411    
412      /** Constructor with InputStream. */
413      public GeneratedFormulaParser(java.io.InputStream stream) {
414         this(stream, null);
415      }
416      /** Constructor with InputStream and supplied encoding */
417      public GeneratedFormulaParser(java.io.InputStream stream, String encoding) {
418        try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
419        token_source = new GeneratedFormulaParserTokenManager(jj_input_stream);
420        token = new Token();
421        token.next = jj_nt = token_source.getNextToken();
422        jj_gen = 0;
423        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
424      }
425    
426      /** Reinitialise. */
427      public void ReInit(java.io.InputStream stream) {
428         ReInit(stream, null);
429      }
430      /** Reinitialise. */
431      public void ReInit(java.io.InputStream stream, String encoding) {
432        try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
433        token_source.ReInit(jj_input_stream);
434        token = new Token();
435        token.next = jj_nt = token_source.getNextToken();
436        jj_gen = 0;
437        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
438      }
439    
440      /** Constructor. */
441      public GeneratedFormulaParser(java.io.Reader stream) {
442        jj_input_stream = new JavaCharStream(stream, 1, 1);
443        token_source = new GeneratedFormulaParserTokenManager(jj_input_stream);
444        token = new Token();
445        token.next = jj_nt = token_source.getNextToken();
446        jj_gen = 0;
447        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
448      }
449    
450      /** Reinitialise. */
451      public void ReInit(java.io.Reader stream) {
452        jj_input_stream.ReInit(stream, 1, 1);
453        token_source.ReInit(jj_input_stream);
454        token = new Token();
455        token.next = jj_nt = token_source.getNextToken();
456        jj_gen = 0;
457        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
458      }
459    
460      /** Constructor with generated Token Manager. */
461      public GeneratedFormulaParser(GeneratedFormulaParserTokenManager tm) {
462        token_source = tm;
463        token = new Token();
464        token.next = jj_nt = token_source.getNextToken();
465        jj_gen = 0;
466        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
467      }
468    
469      /** Reinitialise. */
470      public void ReInit(GeneratedFormulaParserTokenManager tm) {
471        token_source = tm;
472        token = new Token();
473        token.next = jj_nt = token_source.getNextToken();
474        jj_gen = 0;
475        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
476      }
477    
478      private Token jj_consume_token(int kind) throws ParseException {
479        Token oldToken = token;
480        if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
481        else jj_nt = jj_nt.next = token_source.getNextToken();
482        if (token.kind == kind) {
483          jj_gen++;
484          return token;
485        }
486        jj_nt = token;
487        token = oldToken;
488        jj_kind = kind;
489        throw generateParseException();
490      }
491    
492    
493    /** Get the next Token. */
494      final public Token getNextToken() {
495        if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
496        else jj_nt = jj_nt.next = token_source.getNextToken();
497        jj_gen++;
498        return token;
499      }
500    
501    /** Get the specific Token. */
502      final public Token getToken(int index) {
503        Token t = token;
504        for (int i = 0; i < index; i++) {
505          if (t.next != null) t = t.next;
506          else t = t.next = token_source.getNextToken();
507        }
508        return t;
509      }
510    
511      private java.util.List jj_expentries = new java.util.ArrayList();
512      private int[] jj_expentry;
513      private int jj_kind = -1;
514    
515      /** Generate ParseException. */
516      public ParseException generateParseException() {
517        jj_expentries.clear();
518        boolean[] la1tokens = new boolean[49];
519        if (jj_kind >= 0) {
520          la1tokens[jj_kind] = true;
521          jj_kind = -1;
522        }
523        for (int i = 0; i < 13; i++) {
524          if (jj_la1[i] == jj_gen) {
525            for (int j = 0; j < 32; j++) {
526              if ((jj_la1_0[i] & (1<<j)) != 0) {
527                la1tokens[j] = true;
528              }
529              if ((jj_la1_1[i] & (1<<j)) != 0) {
530                la1tokens[32+j] = true;
531              }
532            }
533          }
534        }
535        for (int i = 0; i < 49; i++) {
536          if (la1tokens[i]) {
537            jj_expentry = new int[1];
538            jj_expentry[0] = i;
539            jj_expentries.add(jj_expentry);
540          }
541        }
542        int[][] exptokseq = new int[jj_expentries.size()][];
543        for (int i = 0; i < jj_expentries.size(); i++) {
544          exptokseq[i] = (int[])jj_expentries.get(i);
545        }
546        return new ParseException(token, exptokseq, tokenImage);
547      }
548    
549      /** Enable tracing. */
550      final public void enable_tracing() {
551      }
552    
553      /** Disable tracing. */
554      final public void disable_tracing() {
555      }
556    
557    }