Source for org.jfree.formula.parser.GeneratedFormulaParser

   1: /* Generated By:JavaCC: Do not edit this line. GeneratedFormulaParser.java */
   2: package org.jfree.formula.parser;
   3: 
   4: import java.math.BigDecimal;
   5: import java.util.ArrayList;
   6: 
   7: import org.jfree.formula.lvalues.ContextLookup;
   8: import org.jfree.formula.lvalues.FormulaFunction;
   9: import org.jfree.formula.lvalues.LValue;
  10: import org.jfree.formula.lvalues.PostfixTerm;
  11: import org.jfree.formula.lvalues.PrefixTerm;
  12: import org.jfree.formula.lvalues.StaticValue;
  13: import org.jfree.formula.lvalues.Term;
  14: import org.jfree.formula.lvalues.DefaultDataTable;
  15: import org.jfree.formula.operators.InfixOperator;
  16: import org.jfree.formula.operators.OperatorFactory;
  17: import org.jfree.formula.operators.PostfixOperator;
  18: import org.jfree.formula.operators.PrefixOperator;
  19: import org.jfree.formula.typing.coretypes.NumberType;
  20: import org.jfree.formula.typing.coretypes.TextType;
  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:                 // 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: }