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 }