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 }