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 }