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      public GeneratedFormulaParserTokenManager token_source;
391      JavaCharStream jj_input_stream;
392      public Token token, jj_nt;
393      private int jj_gen;
394      final private int[] jj_la1 = new int[13];
395      static private int[] jj_la1_0;
396      static private int[] jj_la1_1;
397      static {
398          jj_la1_0();
399          jj_la1_1();
400       }
401       private static void jj_la1_0() {
402          jj_la1_0 = new int[] {0xf0000000,0xf0000000,0x30000000,0x2100100,0x0,0x8000000,0x80000,0x32180100,0x80000,0x32100100,0x32180100,0x30000000,0xf0000000,};
403       }
404       private static void jj_la1_1() {
405          jj_la1_1 = new int[] {0xff,0xff,0x0,0x21e00,0x100,0x0,0x0,0x21e00,0x0,0x21e00,0x21e00,0x0,0xff,};
406       }
407    
408      public GeneratedFormulaParser(java.io.InputStream stream) {
409        jj_input_stream = new JavaCharStream(stream, 1, 1);
410        token_source = new GeneratedFormulaParserTokenManager(jj_input_stream);
411        token = new Token();
412        token.next = jj_nt = token_source.getNextToken();
413        jj_gen = 0;
414        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
415      }
416    
417      public void ReInit(java.io.InputStream stream) {
418        jj_input_stream.ReInit(stream, 1, 1);
419        token_source.ReInit(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      public GeneratedFormulaParser(java.io.Reader stream) {
427        jj_input_stream = new JavaCharStream(stream, 1, 1);
428        token_source = new GeneratedFormulaParserTokenManager(jj_input_stream);
429        token = new Token();
430        token.next = jj_nt = token_source.getNextToken();
431        jj_gen = 0;
432        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
433      }
434    
435      public void ReInit(java.io.Reader stream) {
436        jj_input_stream.ReInit(stream, 1, 1);
437        token_source.ReInit(jj_input_stream);
438        token = new Token();
439        token.next = jj_nt = token_source.getNextToken();
440        jj_gen = 0;
441        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
442      }
443    
444      public GeneratedFormulaParser(GeneratedFormulaParserTokenManager tm) {
445        token_source = tm;
446        token = new Token();
447        token.next = jj_nt = token_source.getNextToken();
448        jj_gen = 0;
449        for (int i = 0; i < 13; i++) jj_la1[i] = -1;
450      }
451    
452      public void ReInit(GeneratedFormulaParserTokenManager tm) {
453        token_source = tm;
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      final private Token jj_consume_token(int kind) throws ParseException {
461        Token oldToken = token;
462        if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
463        else jj_nt = jj_nt.next = token_source.getNextToken();
464        if (token.kind == kind) {
465          jj_gen++;
466          return token;
467        }
468        jj_nt = token;
469        token = oldToken;
470        jj_kind = kind;
471        throw generateParseException();
472      }
473    
474      final public Token getNextToken() {
475        if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
476        else jj_nt = jj_nt.next = token_source.getNextToken();
477        jj_gen++;
478        return token;
479      }
480    
481      final public Token getToken(int index) {
482        Token t = token;
483        for (int i = 0; i < index; i++) {
484          if (t.next != null) t = t.next;
485          else t = t.next = token_source.getNextToken();
486        }
487        return t;
488      }
489    
490      private java.util.Vector jj_expentries = new java.util.Vector();
491      private int[] jj_expentry;
492      private int jj_kind = -1;
493    
494      public ParseException generateParseException() {
495        jj_expentries.removeAllElements();
496        boolean[] la1tokens = new boolean[50];
497        for (int i = 0; i < 50; i++) {
498          la1tokens[i] = false;
499        }
500        if (jj_kind >= 0) {
501          la1tokens[jj_kind] = true;
502          jj_kind = -1;
503        }
504        for (int i = 0; i < 13; i++) {
505          if (jj_la1[i] == jj_gen) {
506            for (int j = 0; j < 32; j++) {
507              if ((jj_la1_0[i] & (1<<j)) != 0) {
508                la1tokens[j] = true;
509              }
510              if ((jj_la1_1[i] & (1<<j)) != 0) {
511                la1tokens[32+j] = true;
512              }
513            }
514          }
515        }
516        for (int i = 0; i < 50; i++) {
517          if (la1tokens[i]) {
518            jj_expentry = new int[1];
519            jj_expentry[0] = i;
520            jj_expentries.addElement(jj_expentry);
521          }
522        }
523        int[][] exptokseq = new int[jj_expentries.size()][];
524        for (int i = 0; i < jj_expentries.size(); i++) {
525          exptokseq[i] = (int[])jj_expentries.elementAt(i);
526        }
527        return new ParseException(token, exptokseq, tokenImage);
528      }
529    
530      final public void enable_tracing() {
531      }
532    
533      final public void disable_tracing() {
534      }
535    
536    }