/libformula-1.1.3/source/org/pentaho/reporting/libraries/formula/parser/GeneratedFormulaParser.java
Java | 558 lines | 522 code | 33 blank | 3 comment | 63 complexity | 6ac6bd1e2f5bfbca3f55886a19805beb MD5 | raw file
Possible License(s): LGPL-2.1
1/* Generated By:JavaCC: Do not edit this line. GeneratedFormulaParser.java */
2package org.pentaho.reporting.libraries.formula.parser;
3
4import java.math.BigDecimal;
5import java.util.ArrayList;
6
7import org.pentaho.reporting.libraries.formula.lvalues.ContextLookup;
8import org.pentaho.reporting.libraries.formula.lvalues.FormulaFunction;
9import org.pentaho.reporting.libraries.formula.lvalues.LValue;
10import org.pentaho.reporting.libraries.formula.lvalues.PostfixTerm;
11import org.pentaho.reporting.libraries.formula.lvalues.PrefixTerm;
12import org.pentaho.reporting.libraries.formula.lvalues.StaticValue;
13import org.pentaho.reporting.libraries.formula.lvalues.Term;
14import org.pentaho.reporting.libraries.formula.lvalues.DefaultDataTable;
15import org.pentaho.reporting.libraries.formula.operators.InfixOperator;
16import org.pentaho.reporting.libraries.formula.operators.OperatorFactory;
17import org.pentaho.reporting.libraries.formula.operators.PostfixOperator;
18import org.pentaho.reporting.libraries.formula.operators.PrefixOperator;
19import org.pentaho.reporting.libraries.formula.typing.coretypes.NumberType;
20import org.pentaho.reporting.libraries.formula.typing.coretypes.TextType;
21import org.pentaho.reporting.libraries.formula.lvalues.ParsePosition;
22
23public abstract class GeneratedFormulaParser implements GeneratedFormulaParserConstants {
24
25 protected GeneratedFormulaParser ()
26 {
27 }
28
29 protected abstract OperatorFactory getOperatorFactory();
30
31 protected ParsePosition createPosition(Token token)
32 {
33 return new ParsePosition
34 (token.beginLine, token.beginColumn, token.endLine, token.endColumn);
35 }
36
37 final public LValue getExpression() throws ParseException {
38 LValue retval = null;
39 Term term = null;
40 retval = getLValue();
41 switch (jj_nt.kind) {
42 case PLUS:
43 case MINUS:
44 case MULT:
45 case DIV:
46 case POW:
47 case EQUALS:
48 case NOT_EQUALS:
49 case LT_EQUALS:
50 case GT_EQUALS:
51 case LT:
52 case GT:
53 case CONCAT:
54 term = startTail(new Term(retval));
55 label_1:
56 while (true) {
57 switch (jj_nt.kind) {
58 case PLUS:
59 case MINUS:
60 case MULT:
61 case DIV:
62 case POW:
63 case EQUALS:
64 case NOT_EQUALS:
65 case LT_EQUALS:
66 case GT_EQUALS:
67 case LT:
68 case GT:
69 case CONCAT:
70 ;
71 break;
72 default:
73 jj_la1[0] = jj_gen;
74 break label_1;
75 }
76 term = startTail(term);
77 }
78 break;
79 default:
80 jj_la1[1] = jj_gen;
81 ;
82 }
83 if (term != null)
84 {
85 {if (true) return term;}
86 }
87 {if (true) return retval;}
88 throw new Error("Missing return statement in function");
89 }
90
91 final public Term startTail(LValue retval) throws ParseException {
92 LValue val = null;
93 InfixOperator op = null;
94 Term ex = null;
95 op = getInfixOperator();
96 val = getLValue();
97 if (retval instanceof Term)
98 {
99 ex = (Term) retval;
100 }
101 else
102 {
103 ex = new Term (retval);
104 }
105 ex.add (op, val);
106
107 {if (true) return ex;}
108 throw new Error("Missing return statement in function");
109 }
110
111 final public LValue getLValue() throws ParseException {
112 Token value = null;
113 LValue retval = null;
114 PrefixOperator prefixOp = null;
115 PostfixOperator postfixOp = null;
116 switch (jj_nt.kind) {
117 case PLUS:
118 case MINUS:
119 prefixOp = getPrefixOperator();
120 break;
121 default:
122 jj_la1[2] = jj_gen;
123 ;
124 }
125 switch (jj_nt.kind) {
126 case COLUMN_LOOKUP:
127 value = jj_consume_token(COLUMN_LOOKUP);
128 retval = new ContextLookup (ParserTools.stripReferenceQuote(value.image), createPosition(value));
129 break;
130 case STRING_LITERAL:
131 value = jj_consume_token(STRING_LITERAL);
132 retval = new StaticValue (ParserTools.stripQuote(value.image), TextType.TYPE, createPosition(value));
133 break;
134 case UNSIGNED_NUMERIC_LITERAL:
135 value = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
136 retval = new StaticValue (new BigDecimal (value.image), NumberType.GENERIC_NUMBER, createPosition(value));
137 break;
138 case UNSIGNED_INTEGER:
139 value = jj_consume_token(UNSIGNED_INTEGER);
140 retval = new StaticValue (new BigDecimal (value.image), NumberType.GENERIC_NUMBER, createPosition(value));
141 break;
142 case NULL:
143 jj_consume_token(NULL);
144 retval = new StaticValue (null, createPosition(value));
145 break;
146 case L_BRACE:
147 jj_consume_token(L_BRACE);
148 retval = parseArray();
149 jj_consume_token(R_BRACE);
150 break;
151 case IDENTIFIER:
152 value = jj_consume_token(IDENTIFIER);
153 jj_consume_token(L_PAREN);
154 retval = parseFunction(value.image, createPosition(value));
155 jj_consume_token(R_PAREN);
156 break;
157 case L_PAREN:
158 jj_consume_token(L_PAREN);
159 retval = getExpression ();
160 jj_consume_token(R_PAREN);
161 if (retval instanceof Term == false)
162 {
163 retval = new Term (retval);
164 }
165 break;
166 default:
167 jj_la1[3] = jj_gen;
168 jj_consume_token(-1);
169 throw new ParseException();
170 }
171 switch (jj_nt.kind) {
172 case PERCENT:
173 postfixOp = getPostfixOperator();
174 break;
175 default:
176 jj_la1[4] = jj_gen;
177 ;
178 }
179 if (postfixOp != null)
180 {
181 retval = new PostfixTerm(retval, postfixOp);
182 }
183 if (prefixOp != null)
184 {
185 retval = new PrefixTerm(prefixOp, retval);
186 }
187 {if (true) return retval;}
188 throw new Error("Missing return statement in function");
189 }
190
191 final public LValue parseArray() throws ParseException {
192 ArrayList rows = new ArrayList();
193 LValue[] row = null;
194 row = parseRow();
195 rows.add(row);
196 label_2:
197 while (true) {
198 switch (jj_nt.kind) {
199 case PIPE:
200 ;
201 break;
202 default:
203 jj_la1[5] = jj_gen;
204 break label_2;
205 }
206 jj_consume_token(PIPE);
207 row = parseRow();
208 // should we check here for column count equality to the first row column count?
209 // or do we give this responsability to a DefaultDataTable constructor?
210 rows.add(row);
211 }
212 LValue[][] table = (LValue[][])rows.toArray(new LValue[rows.size()][]);
213 {if (true) return new DefaultDataTable(table);}
214 throw new Error("Missing return statement in function");
215 }
216
217 final public LValue[] parseRow() throws ParseException {
218 ArrayList cols = new ArrayList();;
219 LValue column = null;
220 column = getExpression();
221 cols.add(column);
222 label_3:
223 while (true) {
224 switch (jj_nt.kind) {
225 case SEMICOLON:
226 ;
227 break;
228 default:
229 jj_la1[6] = jj_gen;
230 break label_3;
231 }
232 jj_consume_token(SEMICOLON);
233 column = getExpression();
234 cols.add(column);
235 }
236 {if (true) return (LValue[]) cols.toArray(new LValue[cols.size()]);}
237 throw new Error("Missing return statement in function");
238 }
239
240 final public LValue parseFunction(String name, ParsePosition parsePosition) throws ParseException {
241 ArrayList params = new ArrayList();
242 LValue parameter = null;
243 Token value = null;
244 boolean parameterExpected = false;
245 switch (jj_nt.kind) {
246 case UNSIGNED_INTEGER:
247 case SEMICOLON:
248 case L_PAREN:
249 case L_BRACE:
250 case PLUS:
251 case MINUS:
252 case IDENTIFIER:
253 case COLUMN_LOOKUP:
254 case STRING_LITERAL:
255 case UNSIGNED_NUMERIC_LITERAL:
256 case NULL:
257 switch (jj_nt.kind) {
258 case SEMICOLON:
259 value = jj_consume_token(SEMICOLON);
260 parameterExpected = false;
261 params.add(new StaticValue(null, createPosition(value)));
262 break;
263 case UNSIGNED_INTEGER:
264 case L_PAREN:
265 case L_BRACE:
266 case PLUS:
267 case MINUS:
268 case IDENTIFIER:
269 case COLUMN_LOOKUP:
270 case STRING_LITERAL:
271 case UNSIGNED_NUMERIC_LITERAL:
272 case NULL:
273 parameter = getExpression();
274 parameterExpected = false;
275 params.add(parameter);
276 break;
277 default:
278 jj_la1[7] = jj_gen;
279 jj_consume_token(-1);
280 throw new ParseException();
281 }
282 label_4:
283 while (true) {
284 switch (jj_nt.kind) {
285 case SEMICOLON:
286 ;
287 break;
288 default:
289 jj_la1[8] = jj_gen;
290 break label_4;
291 }
292 value = jj_consume_token(SEMICOLON);
293 if (parameterExpected == true)
294 {
295 params.add(new StaticValue(null, createPosition(value)));
296 }
297 parameterExpected = true;
298 switch (jj_nt.kind) {
299 case UNSIGNED_INTEGER:
300 case L_PAREN:
301 case L_BRACE:
302 case PLUS:
303 case MINUS:
304 case IDENTIFIER:
305 case COLUMN_LOOKUP:
306 case STRING_LITERAL:
307 case UNSIGNED_NUMERIC_LITERAL:
308 case NULL:
309 parameter = getExpression();
310 params.add(parameter);
311 parameterExpected = false;
312 break;
313 default:
314 jj_la1[9] = jj_gen;
315 ;
316 }
317 }
318 break;
319 default:
320 jj_la1[10] = jj_gen;
321 ;
322 }
323 if (parameterExpected == true)
324 {
325 params.add(new StaticValue(null, createPosition(value)));
326 }
327
328 if (params == null)
329 {
330 {if (true) return new FormulaFunction(name, new LValue[0], parsePosition);}
331 }
332
333 LValue[] paramVals = (LValue[]) params.toArray(new LValue[params.size()]);
334 {if (true) return new FormulaFunction(name, paramVals, parsePosition);}
335 throw new Error("Missing return statement in function");
336 }
337
338 final public PrefixOperator getPrefixOperator() throws ParseException {
339 Token value = null;
340 switch (jj_nt.kind) {
341 case PLUS:
342 value = jj_consume_token(PLUS);
343 break;
344 case MINUS:
345 value = jj_consume_token(MINUS);
346 break;
347 default:
348 jj_la1[11] = jj_gen;
349 jj_consume_token(-1);
350 throw new ParseException();
351 }
352 {if (true) return getOperatorFactory().createPrefixOperator(value.image);}
353 throw new Error("Missing return statement in function");
354 }
355
356 final public PostfixOperator getPostfixOperator() throws ParseException {
357 Token value = null;
358 value = jj_consume_token(PERCENT);
359 {if (true) return getOperatorFactory().createPostfixOperator(value.image);}
360 throw new Error("Missing return statement in function");
361 }
362
363 final public InfixOperator getInfixOperator() throws ParseException {
364 InfixOperator op = null;
365 Token value = null;
366 switch (jj_nt.kind) {
367 case PLUS:
368 value = jj_consume_token(PLUS);
369 break;
370 case MINUS:
371 value = jj_consume_token(MINUS);
372 break;
373 case MULT:
374 value = jj_consume_token(MULT);
375 break;
376 case DIV:
377 value = jj_consume_token(DIV);
378 break;
379 case POW:
380 value = jj_consume_token(POW);
381 break;
382 case EQUALS:
383 value = jj_consume_token(EQUALS);
384 break;
385 case NOT_EQUALS:
386 value = jj_consume_token(NOT_EQUALS);
387 break;
388 case LT_EQUALS:
389 value = jj_consume_token(LT_EQUALS);
390 break;
391 case GT_EQUALS:
392 value = jj_consume_token(GT_EQUALS);
393 break;
394 case LT:
395 value = jj_consume_token(LT);
396 break;
397 case GT:
398 value = jj_consume_token(GT);
399 break;
400 case CONCAT:
401 value = jj_consume_token(CONCAT);
402 break;
403 default:
404 jj_la1[12] = jj_gen;
405 jj_consume_token(-1);
406 throw new ParseException();
407 }
408 {if (true) return getOperatorFactory().createInfixOperator(value.image);}
409 throw new Error("Missing return statement in function");
410 }
411
412 public GeneratedFormulaParserTokenManager token_source;
413 JavaCharStream jj_input_stream;
414 public Token token, jj_nt;
415 private int jj_gen;
416 final private int[] jj_la1 = new int[13];
417 static private int[] jj_la1_0;
418 static private int[] jj_la1_1;
419 static {
420 jj_la1_0();
421 jj_la1_1();
422 }
423 private static void jj_la1_0() {
424 jj_la1_0 = new int[] {0xf8000000,0xf8000000,0x18000000,0x1080100,0x0,0x4000000,0x40000,0x190c0100,0x40000,0x19080100,0x190c0100,0x18000000,0xf8000000,};
425 }
426 private static void jj_la1_1() {
427 jj_la1_1 = new int[] {0x7f,0x7f,0x0,0x10f00,0x80,0x0,0x0,0x10f00,0x0,0x10f00,0x10f00,0x0,0x7f,};
428 }
429
430 public GeneratedFormulaParser(java.io.InputStream stream) {
431 jj_input_stream = new JavaCharStream(stream, 1, 1);
432 token_source = new GeneratedFormulaParserTokenManager(jj_input_stream);
433 token = new Token();
434 token.next = jj_nt = token_source.getNextToken();
435 jj_gen = 0;
436 for (int i = 0; i < 13; i++) jj_la1[i] = -1;
437 }
438
439 public void ReInit(java.io.InputStream stream) {
440 jj_input_stream.ReInit(stream, 1, 1);
441 token_source.ReInit(jj_input_stream);
442 token = new Token();
443 token.next = jj_nt = token_source.getNextToken();
444 jj_gen = 0;
445 for (int i = 0; i < 13; i++) jj_la1[i] = -1;
446 }
447
448 public GeneratedFormulaParser(java.io.Reader stream) {
449 jj_input_stream = new JavaCharStream(stream, 1, 1);
450 token_source = new GeneratedFormulaParserTokenManager(jj_input_stream);
451 token = new Token();
452 token.next = jj_nt = token_source.getNextToken();
453 jj_gen = 0;
454 for (int i = 0; i < 13; i++) jj_la1[i] = -1;
455 }
456
457 public void ReInit(java.io.Reader stream) {
458 jj_input_stream.ReInit(stream, 1, 1);
459 token_source.ReInit(jj_input_stream);
460 token = new Token();
461 token.next = jj_nt = token_source.getNextToken();
462 jj_gen = 0;
463 for (int i = 0; i < 13; i++) jj_la1[i] = -1;
464 }
465
466 public GeneratedFormulaParser(GeneratedFormulaParserTokenManager tm) {
467 token_source = tm;
468 token = new Token();
469 token.next = jj_nt = token_source.getNextToken();
470 jj_gen = 0;
471 for (int i = 0; i < 13; i++) jj_la1[i] = -1;
472 }
473
474 public void ReInit(GeneratedFormulaParserTokenManager tm) {
475 token_source = tm;
476 token = new Token();
477 token.next = jj_nt = token_source.getNextToken();
478 jj_gen = 0;
479 for (int i = 0; i < 13; i++) jj_la1[i] = -1;
480 }
481
482 final private Token jj_consume_token(int kind) throws ParseException {
483 Token oldToken = token;
484 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
485 else jj_nt = jj_nt.next = token_source.getNextToken();
486 if (token.kind == kind) {
487 jj_gen++;
488 return token;
489 }
490 jj_nt = token;
491 token = oldToken;
492 jj_kind = kind;
493 throw generateParseException();
494 }
495
496 final public Token getNextToken() {
497 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
498 else jj_nt = jj_nt.next = token_source.getNextToken();
499 jj_gen++;
500 return token;
501 }
502
503 final public Token getToken(int index) {
504 Token t = token;
505 for (int i = 0; i < index; i++) {
506 if (t.next != null) t = t.next;
507 else t = t.next = token_source.getNextToken();
508 }
509 return t;
510 }
511
512 private java.util.Vector jj_expentries = new java.util.Vector();
513 private int[] jj_expentry;
514 private int jj_kind = -1;
515
516 public ParseException generateParseException() {
517 jj_expentries.removeAllElements();
518 boolean[] la1tokens = new boolean[49];
519 for (int i = 0; i < 49; i++) {
520 la1tokens[i] = false;
521 }
522 if (jj_kind >= 0) {
523 la1tokens[jj_kind] = true;
524 jj_kind = -1;
525 }
526 for (int i = 0; i < 13; i++) {
527 if (jj_la1[i] == jj_gen) {
528 for (int j = 0; j < 32; j++) {
529 if ((jj_la1_0[i] & (1<<j)) != 0) {
530 la1tokens[j] = true;
531 }
532 if ((jj_la1_1[i] & (1<<j)) != 0) {
533 la1tokens[32+j] = true;
534 }
535 }
536 }
537 }
538 for (int i = 0; i < 49; i++) {
539 if (la1tokens[i]) {
540 jj_expentry = new int[1];
541 jj_expentry[0] = i;
542 jj_expentries.addElement(jj_expentry);
543 }
544 }
545 int[][] exptokseq = new int[jj_expentries.size()][];
546 for (int i = 0; i < jj_expentries.size(); i++) {
547 exptokseq[i] = (int[])jj_expentries.elementAt(i);
548 }
549 return new ParseException(token, exptokseq, tokenImage);
550 }
551
552 final public void enable_tracing() {
553 }
554
555 final public void disable_tracing() {
556 }
557
558}