1:
2: package ;
3:
4: import ;
5: import ;
6:
7: import ;
8: import ;
9: import ;
10: import ;
11: import ;
12: import ;
13: import ;
14: import ;
15: import ;
16: import ;
17: import ;
18: import ;
19: import ;
20: import ;
21:
22: public abstract class GeneratedFormulaParser implements GeneratedFormulaParserConstants {
23:
24: protected GeneratedFormulaParser ()
25: {
26: }
27:
28: protected abstract OperatorFactory getOperatorFactory();
29:
30: final public LValue getExpression() throws ParseException {
31: LValue retval = null;
32: Term term = null;
33: retval = getLValue();
34: switch (jj_nt.kind) {
35: case PLUS:
36: case MINUS:
37: case MULT:
38: case DIV:
39: case POW:
40: case EQUALS:
41: case NOT_EQUALS:
42: case LT_EQUALS:
43: case GT_EQUALS:
44: case LT:
45: case GT:
46: case CONCAT:
47: term = startTail(new Term(retval));
48: label_1:
49: while (true) {
50: switch (jj_nt.kind) {
51: case PLUS:
52: case MINUS:
53: case MULT:
54: case DIV:
55: case POW:
56: case EQUALS:
57: case NOT_EQUALS:
58: case LT_EQUALS:
59: case GT_EQUALS:
60: case LT:
61: case GT:
62: case CONCAT:
63: ;
64: break;
65: default:
66: jj_la1[0] = jj_gen;
67: break label_1;
68: }
69: term = startTail(term);
70: }
71: break;
72: default:
73: jj_la1[1] = jj_gen;
74: ;
75: }
76: if (term != null)
77: {
78: {if (true) return term;}
79: }
80: {if (true) return retval;}
81: throw new Error("Missing return statement in function");
82: }
83:
84: final public Term startTail(LValue retval) throws ParseException {
85: LValue val = null;
86: InfixOperator op = null;
87: Term ex = null;
88: op = getInfixOperator();
89: val = getLValue();
90: if (retval instanceof Term)
91: {
92: ex = (Term) retval;
93: }
94: else
95: {
96: ex = new Term (retval);
97: }
98: ex.add (op, val);
99:
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:
202:
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:
391: public GeneratedFormulaParserTokenManager token_source;
392: JavaCharStream jj_input_stream;
393:
394: public Token token;
395:
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:
413: public GeneratedFormulaParser(java.io.InputStream stream) {
414: this(stream, null);
415: }
416:
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:
427: public void ReInit(java.io.InputStream stream) {
428: ReInit(stream, null);
429: }
430:
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:
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:
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:
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:
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:
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:
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:
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:
550: final public void enable_tracing() {
551: }
552:
553:
554: final public void disable_tracing() {
555: }
556:
557: }