bundles/org.simantics.spreadsheet.graph/src/org/simantics/spreadsheet/graph/parser/SheetFormulaParser.java

   1 /* Generated By:JavaCC: Do not edit this line. SheetFormulaParser.java */
   2 package org.simantics.spreadsheet.graph.parser;
   3
   4 import org.simantics.spreadsheet.graph.parser.ast.*;
   5 import java.util.ArrayList;
   6 import java.util.List;
   7 import java.util.Collections;
   8
   9 /**
  10  * Parser for spreadsheet formulas
  11  * @author Antti Villberg
  12  */
  13 public class SheetFormulaParser implements SheetFormulaParserConstants {
  14
  15   final public AstValue primary() throws ParseException {
  16     Token tok;
  17     AstValue temp;
  18     AstRange tempRange;
  19     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  20     case 27:
  21       jj_consume_token(27);
  22              {if (true) return AstNull.NULL;}
  23       break;
  24     case 25:
  25       jj_consume_token(25);
  26              {if (true) return AstBoolean.TRUE;}
  27       break;
  28     case 26:
  29       jj_consume_token(26);
  30               {if (true) return AstBoolean.FALSE;}
  31       break;
  32     case 28:
  33       jj_consume_token(28);
  34              {if (true) return AstBoolean.TRUE;}
  35       break;
  36     case 29:
  37       jj_consume_token(29);
  38               {if (true) return AstBoolean.FALSE;}
  39       break;
  40     case STRING:
  41       jj_consume_token(STRING);
  42                {if (true) return new AstString(token.image);}
  43       break;
  44     case LONG_STRING:
  45       jj_consume_token(LONG_STRING);
  46                     {if (true) return new AstString(token.image);}
  47       break;
  48     case FLOAT:
  49       jj_consume_token(FLOAT);
  50               {if (true) return new AstDouble(token.image);}
  51       break;
  52     case INTEGER:
  53       jj_consume_token(INTEGER);
  54                 {if (true) return new AstInteger(Integer.parseInt(token.image));}
  55       break;
  56     default:
  57       jj_la1[1] = jj_gen;
  58       if (jj_2_1(2)) {
  59         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  60         case IDENT:
  61           tok = jj_consume_token(IDENT);
  62           break;
  63         case SHEET_NAME:
  64           tok = jj_consume_token(SHEET_NAME);
  65           break;
  66         default:
  67           jj_la1[0] = jj_gen;
  68           jj_consume_token(-1);
  69           throw new ParseException();
  70         }
  71         jj_consume_token(42);
  72         tempRange = range();
  73                                                                                 {if (true) return tempRange.inSheet(tok.image);}
  74       } else if (jj_2_2(2)) {
  75         temp = apply();
  76                                   {if (true) return temp;}
  77       } else {
  78         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  79         case 5:
  80           jj_consume_token(5);
  81           temp = relation();
  82           jj_consume_token(6);
  83                                 {if (true) return temp;}
  84           break;
  85         case CELL_SINGLE:
  86         case CELL_RANGE:
  87         case 43:
  88           temp = range();
  89                      {if (true) return temp;}
  90           break;
  91         case 10:
  92           temp = array();
  93                      {if (true) return temp;}
  94           break;
  95         case IDENT:
  96           jj_consume_token(IDENT);
  97               {if (true) return new AstIdentifier(token.image);}
  98           break;
  99         default:
 100           jj_la1[2] = jj_gen;
 101           jj_consume_token(-1);
 102           throw new ParseException();
 103         }
 104       }
 105     }
 106     throw new Error("Missing return statement in function");
 107   }
 108
 109   final public AstApply apply() throws ParseException {
 110     AstArgList al;
 111     Token tok;
 112     if (jj_2_3(3)) {
 113       tok = jj_consume_token(IDENT);
 114       jj_consume_token(5);
 115       jj_consume_token(6);
 116                                        {if (true) return new AstApply(tok.image, null);}
 117     } else {
 118       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 119       case IDENT:
 120         tok = jj_consume_token(IDENT);
 121         jj_consume_token(5);
 122         al = arglist();
 123         jj_consume_token(6);
 124                                          {if (true) return new AstApply(tok.image, al);}
 125         break;
 126       default:
 127         jj_la1[3] = jj_gen;
 128         jj_consume_token(-1);
 129         throw new ParseException();
 130       }
 131     }
 132     throw new Error("Missing return statement in function");
 133   }
 134
 135   final public AstValue array() throws ParseException {
 136     AstArray arr = new AstArray();
 137     AstValue temp;
 138     if (jj_2_4(2)) {
 139       jj_consume_token(10);
 140       jj_consume_token(11);
 141                          {if (true) return new AstArray();}
 142     } else {
 143       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 144       case 10:
 145         jj_consume_token(10);
 146         temp = relation();
 147                           arr.add(temp);
 148         jj_consume_token(18);
 149         label_1:
 150         while (true) {
 151           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 152           case 5:
 153           case 10:
 154           case 13:
 155           case 14:
 156           case 25:
 157           case 26:
 158           case 27:
 159           case 28:
 160           case 29:
 161           case STRING:
 162           case SHEET_NAME:
 163           case LONG_STRING:
 164           case CELL_SINGLE:
 165           case CELL_RANGE:
 166           case IDENT:
 167           case FLOAT:
 168           case INTEGER:
 169           case 43:
 170           case 46:
 171             ;
 172             break;
 173           default:
 174             jj_la1[4] = jj_gen;
 175             break label_1;
 176           }
 177           temp = relation();
 178                                                                      arr.add(temp);
 179         }
 180         jj_consume_token(11);
 181                                                                                                {if (true) return arr;}
 182         break;
 183       default:
 184         jj_la1[5] = jj_gen;
 185         jj_consume_token(-1);
 186         throw new ParseException();
 187       }
 188     }
 189     throw new Error("Missing return statement in function");
 190   }
 191
 192   final public AstRange range() throws ParseException {
 193     Token temp1;
 194     Token temp2;
 195     if (jj_2_5(2)) {
 196       jj_consume_token(CELL_RANGE);
 197                               {if (true) return new AstRange(token.image);}
 198     } else {
 199       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 200       case CELL_SINGLE:
 201         jj_consume_token(CELL_SINGLE);
 202                      {if (true) return new AstRange(token.image);}
 203         break;
 204       case 43:
 205         jj_consume_token(43);
 206                {if (true) return AstRange.REF;}
 207         break;
 208       default:
 209         jj_la1[6] = jj_gen;
 210         jj_consume_token(-1);
 211         throw new ParseException();
 212       }
 213     }
 214     throw new Error("Missing return statement in function");
 215   }
 216
 217   final public AstArgList arglist() throws ParseException {
 218     AstArgList ret = new AstArgList();
 219     AstValue temp;
 220     temp = relation();
 221                        ret.add(temp);
 222     label_2:
 223     while (true) {
 224       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 225       case 4:
 226       case 18:
 227         ;
 228         break;
 229       default:
 230         jj_la1[7] = jj_gen;
 231         break label_2;
 232       }
 233       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 234       case 4:
 235         jj_consume_token(4);
 236         break;
 237       case 18:
 238         jj_consume_token(18);
 239         break;
 240       default:
 241         jj_la1[8] = jj_gen;
 242         jj_consume_token(-1);
 243         throw new ParseException();
 244       }
 245                 temp = AstNothing.INSTANCE;
 246       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 247       case 5:
 248       case 10:
 249       case 13:
 250       case 14:
 251       case 25:
 252       case 26:
 253       case 27:
 254       case 28:
 255       case 29:
 256       case STRING:
 257       case SHEET_NAME:
 258       case LONG_STRING:
 259       case CELL_SINGLE:
 260       case CELL_RANGE:
 261       case IDENT:
 262       case FLOAT:
 263       case INTEGER:
 264       case 43:
 265       case 46:
 266         temp = relation();
 267         break;
 268       default:
 269         jj_la1[9] = jj_gen;
 270         ;
 271       }
 272                                                                      ret.add(temp);
 273     }
 274                                                                                             {if (true) return ret;}
 275     throw new Error("Missing return statement in function");
 276   }
 277
 278   final public AstValue relation() throws ParseException {
 279   AstRelation ret;
 280   String op;
 281   AstValue ex;
 282     ex = arithmetic_expression();
 283                                         ret = new AstRelation(ex);
 284     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 285     case 21:
 286     case 22:
 287     case 23:
 288     case 24:
 289     case 44:
 290     case 45:
 291       op = rel_op();
 292       ex = arithmetic_expression();
 293                                                                                                                         ret.setRight(op, ex);
 294       break;
 295     default:
 296       jj_la1[10] = jj_gen;
 297       ;
 298     }
 299                                                                                                                                                      {if (true) return ret.simplify();}
 300     throw new Error("Missing return statement in function");
 301   }
 302
 303   final public String rel_op() throws ParseException {
 304     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 305     case 22:
 306       jj_consume_token(22);
 307               {if (true) return "< ";}
 308       break;
 309     case 44:
 310       jj_consume_token(44);
 311                                      {if (true) return "<=";}
 312       break;
 313     case 23:
 314       jj_consume_token(23);
 315                                                            {if (true) return " >";}
 316       break;
 317     case 45:
 318       jj_consume_token(45);
 319                                                                                   {if (true) return " >=";}
 320       break;
 321     case 21:
 322       jj_consume_token(21);
 323                                                                                                          {if (true) return "=";}
 324       break;
 325     case 24:
 326       jj_consume_token(24);
 327                                                                                                                                {if (true) return "<>";}
 328       break;
 329     default:
 330       jj_la1[11] = jj_gen;
 331       jj_consume_token(-1);
 332       throw new ParseException();
 333     }
 334     throw new Error("Missing return statement in function");
 335   }
 336
 337 //
 338   final public AstValue arithmetic_expression() throws ParseException {
 339     AstArithmeticExpression ret;
 340     String op = null;
 341     AstValue temp;
 342     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 343     case 13:
 344     case 14:
 345     case 46:
 346       op = add_op();
 347       break;
 348     default:
 349       jj_la1[12] = jj_gen;
 350       ;
 351     }
 352     temp = term();
 353                                    ret = new AstArithmeticExpression(op, temp);
 354     label_3:
 355     while (true) {
 356       if (jj_2_6(2)) {
 357         ;
 358       } else {
 359         break label_3;
 360       }
 361       op = add_op();
 362       temp = term();
 363                                                                                                                                ret.add(op, temp);
 364     }
 365                                                                                                                                                          {if (true) return ret.simplify();}
 366     throw new Error("Missing return statement in function");
 367   }
 368
 369   final public String add_op() throws ParseException {
 370     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 371     case 14:
 372       jj_consume_token(14);
 373           {if (true) return "+";}
 374       break;
 375     case 46:
 376       jj_consume_token(46);
 377                                {if (true) return "-";}
 378       break;
 379     case 13:
 380       jj_consume_token(13);
 381                                                     {if (true) return "&";}
 382       break;
 383     default:
 384       jj_la1[13] = jj_gen;
 385       jj_consume_token(-1);
 386       throw new ParseException();
 387     }
 388     throw new Error("Missing return statement in function");
 389   }
 390
 391   final public AstValue term() throws ParseException {
 392     AstTerm ret;
 393     String op;
 394     AstValue temp;
 395     temp = factor();
 396                     ret = new AstTerm(temp);
 397     label_4:
 398     while (true) {
 399       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 400       case 15:
 401       case 16:
 402         ;
 403         break;
 404       default:
 405         jj_la1[14] = jj_gen;
 406         break label_4;
 407       }
 408       op = mul_op();
 409       temp = factor();
 410                                                                                 ret.add(op, temp);
 411     }
 412                                                                                                           {if (true) return ret.simplify();}
 413     throw new Error("Missing return statement in function");
 414   }
 415
 416   final public String mul_op() throws ParseException {
 417     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 418     case 15:
 419       jj_consume_token(15);
 420           {if (true) return "*";}
 421       break;
 422     case 16:
 423       jj_consume_token(16);
 424                                {if (true) return "/";}
 425       break;
 426     default:
 427       jj_la1[15] = jj_gen;
 428       jj_consume_token(-1);
 429       throw new ParseException();
 430     }
 431     throw new Error("Missing return statement in function");
 432   }
 433
 434   final public AstValue factor() throws ParseException {
 435     AstFactor ret;
 436     String op;
 437     AstValue temp;
 438     temp = primary();
 439                      ret = new AstFactor(temp);
 440     label_5:
 441     while (true) {
 442       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 443       case 17:
 444         ;
 445         break;
 446       default:
 447         jj_la1[16] = jj_gen;
 448         break label_5;
 449       }
 450       op = factor_op();
 451       temp = primary();
 452                                                                                        ret.add(op, temp);
 453     }
 454                                                                                                                  {if (true) return ret.simplify();}
 455     throw new Error("Missing return statement in function");
 456   }
 457
 458   final public String factor_op() throws ParseException {
 459     jj_consume_token(17);
 460           {if (true) return "^";}
 461     throw new Error("Missing return statement in function");
 462   }
 463
 464   private boolean jj_2_1(int xla) {
 465     jj_la = xla; jj_lastpos = jj_scanpos = token;
 466     try { return !jj_3_1(); }
 467     catch(LookaheadSuccess ls) { return true; }
 468     finally { jj_save(0, xla); }
 469   }
 470
 471   private boolean jj_2_2(int xla) {
 472     jj_la = xla; jj_lastpos = jj_scanpos = token;
 473     try { return !jj_3_2(); }
 474     catch(LookaheadSuccess ls) { return true; }
 475     finally { jj_save(1, xla); }
 476   }
 477
 478   private boolean jj_2_3(int xla) {
 479     jj_la = xla; jj_lastpos = jj_scanpos = token;
 480     try { return !jj_3_3(); }
 481     catch(LookaheadSuccess ls) { return true; }
 482     finally { jj_save(2, xla); }
 483   }
 484
 485   private boolean jj_2_4(int xla) {
 486     jj_la = xla; jj_lastpos = jj_scanpos = token;
 487     try { return !jj_3_4(); }
 488     catch(LookaheadSuccess ls) { return true; }
 489     finally { jj_save(3, xla); }
 490   }
 491
 492   private boolean jj_2_5(int xla) {
 493     jj_la = xla; jj_lastpos = jj_scanpos = token;
 494     try { return !jj_3_5(); }
 495     catch(LookaheadSuccess ls) { return true; }
 496     finally { jj_save(4, xla); }
 497   }
 498
 499   private boolean jj_2_6(int xla) {
 500     jj_la = xla; jj_lastpos = jj_scanpos = token;
 501     try { return !jj_3_6(); }
 502     catch(LookaheadSuccess ls) { return true; }
 503     finally { jj_save(5, xla); }
 504   }
 505
 506   private boolean jj_3R_29() {
 507     Token xsp;
 508     xsp = jj_scanpos;
 509     if (jj_3_4()) {
 510     jj_scanpos = xsp;
 511     if (jj_3R_32()) return true;
 512     }
 513     return false;
 514   }
 515
 516   private boolean jj_3_4() {
 517     if (jj_scan_token(10)) return true;
 518     if (jj_scan_token(11)) return true;
 519     return false;
 520   }
 521
 522   private boolean jj_3R_7() {
 523     Token xsp;
 524     xsp = jj_scanpos;
 525     if (jj_3R_10()) {
 526     jj_scanpos = xsp;
 527     if (jj_3R_11()) {
 528     jj_scanpos = xsp;
 529     if (jj_3R_12()) return true;
 530     }
 531     }
 532     return false;
 533   }
 534
 535   private boolean jj_3R_10() {
 536     if (jj_scan_token(14)) return true;
 537     return false;
 538   }
 539
 540   private boolean jj_3R_12() {
 541     if (jj_scan_token(13)) return true;
 542     return false;
 543   }
 544
 545   private boolean jj_3R_9() {
 546     if (jj_scan_token(IDENT)) return true;
 547     if (jj_scan_token(5)) return true;
 548     return false;
 549   }
 550
 551   private boolean jj_3R_6() {
 552     Token xsp;
 553     xsp = jj_scanpos;
 554     if (jj_3_3()) {
 555     jj_scanpos = xsp;
 556     if (jj_3R_9()) return true;
 557     }
 558     return false;
 559   }
 560
 561   private boolean jj_3_3() {
 562     if (jj_scan_token(IDENT)) return true;
 563     if (jj_scan_token(5)) return true;
 564     if (jj_scan_token(6)) return true;
 565     return false;
 566   }
 567
 568   private boolean jj_3R_27() {
 569     if (jj_scan_token(IDENT)) return true;
 570     return false;
 571   }
 572
 573   private boolean jj_3R_26() {
 574     if (jj_3R_29()) return true;
 575     return false;
 576   }
 577
 578   private boolean jj_3R_25() {
 579     if (jj_3R_28()) return true;
 580     return false;
 581   }
 582
 583   private boolean jj_3R_24() {
 584     if (jj_scan_token(5)) return true;
 585     return false;
 586   }
 587
 588   private boolean jj_3_2() {
 589     if (jj_3R_6()) return true;
 590     return false;
 591   }
 592
 593   private boolean jj_3_1() {
 594     Token xsp;
 595     xsp = jj_scanpos;
 596     if (jj_scan_token(38)) {
 597     jj_scanpos = xsp;
 598     if (jj_scan_token(33)) return true;
 599     }
 600     if (jj_scan_token(42)) return true;
 601     return false;
 602   }
 603
 604   private boolean jj_3R_23() {
 605     if (jj_scan_token(INTEGER)) return true;
 606     return false;
 607   }
 608
 609   private boolean jj_3_6() {
 610     if (jj_3R_7()) return true;
 611     if (jj_3R_8()) return true;
 612     return false;
 613   }
 614
 615   private boolean jj_3R_22() {
 616     if (jj_scan_token(FLOAT)) return true;
 617     return false;
 618   }
 619
 620   private boolean jj_3R_21() {
 621     if (jj_scan_token(LONG_STRING)) return true;
 622     return false;
 623   }
 624
 625   private boolean jj_3R_20() {
 626     if (jj_scan_token(STRING)) return true;
 627     return false;
 628   }
 629
 630   private boolean jj_3R_19() {
 631     if (jj_scan_token(29)) return true;
 632     return false;
 633   }
 634
 635   private boolean jj_3R_18() {
 636     if (jj_scan_token(28)) return true;
 637     return false;
 638   }
 639
 640   private boolean jj_3R_17() {
 641     if (jj_scan_token(26)) return true;
 642     return false;
 643   }
 644
 645   private boolean jj_3R_11() {
 646     if (jj_scan_token(46)) return true;
 647     return false;
 648   }
 649
 650   private boolean jj_3R_16() {
 651     if (jj_scan_token(25)) return true;
 652     return false;
 653   }
 654
 655   private boolean jj_3R_13() {
 656     if (jj_3R_14()) return true;
 657     return false;
 658   }
 659
 660   private boolean jj_3R_14() {
 661     Token xsp;
 662     xsp = jj_scanpos;
 663     if (jj_3R_15()) {
 664     jj_scanpos = xsp;
 665     if (jj_3R_16()) {
 666     jj_scanpos = xsp;
 667     if (jj_3R_17()) {
 668     jj_scanpos = xsp;
 669     if (jj_3R_18()) {
 670     jj_scanpos = xsp;
 671     if (jj_3R_19()) {
 672     jj_scanpos = xsp;
 673     if (jj_3R_20()) {
 674     jj_scanpos = xsp;
 675     if (jj_3R_21()) {
 676     jj_scanpos = xsp;
 677     if (jj_3R_22()) {
 678     jj_scanpos = xsp;
 679     if (jj_3R_23()) {
 680     jj_scanpos = xsp;
 681     if (jj_3_1()) {
 682     jj_scanpos = xsp;
 683     if (jj_3_2()) {
 684     jj_scanpos = xsp;
 685     if (jj_3R_24()) {
 686     jj_scanpos = xsp;
 687     if (jj_3R_25()) {
 688     jj_scanpos = xsp;
 689     if (jj_3R_26()) {
 690     jj_scanpos = xsp;
 691     if (jj_3R_27()) return true;
 692     }
 693     }
 694     }
 695     }
 696     }
 697     }
 698     }
 699     }
 700     }
 701     }
 702     }
 703     }
 704     }
 705     }
 706     return false;
 707   }
 708
 709   private boolean jj_3R_15() {
 710     if (jj_scan_token(27)) return true;
 711     return false;
 712   }
 713
 714   private boolean jj_3R_31() {
 715     if (jj_scan_token(43)) return true;
 716     return false;
 717   }
 718
 719   private boolean jj_3R_30() {
 720     if (jj_scan_token(CELL_SINGLE)) return true;
 721     return false;
 722   }
 723
 724   private boolean jj_3R_28() {
 725     Token xsp;
 726     xsp = jj_scanpos;
 727     if (jj_3_5()) {
 728     jj_scanpos = xsp;
 729     if (jj_3R_30()) {
 730     jj_scanpos = xsp;
 731     if (jj_3R_31()) return true;
 732     }
 733     }
 734     return false;
 735   }
 736
 737   private boolean jj_3_5() {
 738     if (jj_scan_token(CELL_RANGE)) return true;
 739     return false;
 740   }
 741
 742   private boolean jj_3R_8() {
 743     if (jj_3R_13()) return true;
 744     return false;
 745   }
 746
 747   private boolean jj_3R_32() {
 748     if (jj_scan_token(10)) return true;
 749     return false;
 750   }
 751
 752   /** Generated Token Manager. */
 753   public SheetFormulaParserTokenManager token_source;
 754   SimpleCharStream jj_input_stream;
 755   /** Current token. */
 756   public Token token;
 757   /** Next token. */
 758   public Token jj_nt;
 759   private int jj_ntk;
 760   private Token jj_scanpos, jj_lastpos;
 761   private int jj_la;
 762   private int jj_gen;
 763   final private int[] jj_la1 = new int[17];
 764   static private int[] jj_la1_0;
 765   static private int[] jj_la1_1;
 766   static {
 767       jj_la1_init_0();
 768       jj_la1_init_1();
 769    }
 770    private static void jj_la1_init_0() {
 771       jj_la1_0 = new int[] {0x0,0x3e000000,0x420,0x0,0x3e006420,0x400,0x0,0x40010,0x40010,0x3e006420,0x1e00000,0x1e00000,0x6000,0x6000,0x18000,0x18000,0x20000,};
 772    }
 773    private static void jj_la1_init_1() {
 774       jj_la1_1 = new int[] {0x42,0x305,0x868,0x40,0x4b6f,0x0,0x808,0x0,0x0,0x4b6f,0x3000,0x3000,0x4000,0x4000,0x0,0x0,0x0,};
 775    }
 776   final private JJCalls[] jj_2_rtns = new JJCalls[6];
 777   private boolean jj_rescan = false;
 778   private int jj_gc = 0;
 779
 780   /** Constructor with InputStream. */
 781   public SheetFormulaParser(java.io.InputStream stream) {
 782      this(stream, null);
 783   }
 784   /** Constructor with InputStream and supplied encoding */
 785   public SheetFormulaParser(java.io.InputStream stream, String encoding) {
 786     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
 787     token_source = new SheetFormulaParserTokenManager(jj_input_stream);
 788     token = new Token();
 789     jj_ntk = -1;
 790     jj_gen = 0;
 791     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
 792     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 793   }
 794
 795   /** Reinitialise. */
 796   public void ReInit(java.io.InputStream stream) {
 797      ReInit(stream, null);
 798   }
 799   /** Reinitialise. */
 800   public void ReInit(java.io.InputStream stream, String encoding) {
 801     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
 802     token_source.ReInit(jj_input_stream);
 803     token = new Token();
 804     jj_ntk = -1;
 805     jj_gen = 0;
 806     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
 807     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 808   }
 809
 810   /** Constructor. */
 811   public SheetFormulaParser(java.io.Reader stream) {
 812     jj_input_stream = new SimpleCharStream(stream, 1, 1);
 813     token_source = new SheetFormulaParserTokenManager(jj_input_stream);
 814     token = new Token();
 815     jj_ntk = -1;
 816     jj_gen = 0;
 817     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
 818     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 819   }
 820
 821   /** Reinitialise. */
 822   public void ReInit(java.io.Reader stream) {
 823     jj_input_stream.ReInit(stream, 1, 1);
 824     token_source.ReInit(jj_input_stream);
 825     token = new Token();
 826     jj_ntk = -1;
 827     jj_gen = 0;
 828     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
 829     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 830   }
 831
 832   /** Constructor with generated Token Manager. */
 833   public SheetFormulaParser(SheetFormulaParserTokenManager tm) {
 834     token_source = tm;
 835     token = new Token();
 836     jj_ntk = -1;
 837     jj_gen = 0;
 838     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
 839     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 840   }
 841
 842   /** Reinitialise. */
 843   public void ReInit(SheetFormulaParserTokenManager tm) {
 844     token_source = tm;
 845     token = new Token();
 846     jj_ntk = -1;
 847     jj_gen = 0;
 848     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
 849     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 850   }
 851
 852   private Token jj_consume_token(int kind) throws ParseException {
 853     Token oldToken;
 854     if ((oldToken = token).next != null) token = token.next;
 855     else token = token.next = token_source.getNextToken();
 856     jj_ntk = -1;
 857     if (token.kind == kind) {
 858       jj_gen++;
 859       if (++jj_gc > 100) {
 860         jj_gc = 0;
 861         for (int i = 0; i < jj_2_rtns.length; i++) {
 862           JJCalls c = jj_2_rtns[i];
 863           while (c != null) {
 864             if (c.gen < jj_gen) c.first = null;
 865             c = c.next;
 866           }
 867         }
 868       }
 869       return token;
 870     }
 871     token = oldToken;
 872     jj_kind = kind;
 873     throw generateParseException();
 874   }
 875
 876   static private final class LookaheadSuccess extends java.lang.Error { }
 877   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
 878   private boolean jj_scan_token(int kind) {
 879     if (jj_scanpos == jj_lastpos) {
 880       jj_la--;
 881       if (jj_scanpos.next == null) {
 882         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
 883       } else {
 884         jj_lastpos = jj_scanpos = jj_scanpos.next;
 885       }
 886     } else {
 887       jj_scanpos = jj_scanpos.next;
 888     }
 889     if (jj_rescan) {
 890       int i = 0; Token tok = token;
 891       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
 892       if (tok != null) jj_add_error_token(kind, i);
 893     }
 894     if (jj_scanpos.kind != kind) return true;
 895     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
 896     return false;
 897   }
 898
 899
 900 /** Get the next Token. */
 901   final public Token getNextToken() {
 902     if (token.next != null) token = token.next;
 903     else token = token.next = token_source.getNextToken();
 904     jj_ntk = -1;
 905     jj_gen++;
 906     return token;
 907   }
 908
 909 /** Get the specific Token. */
 910   final public Token getToken(int index) {
 911     Token t = token;
 912     for (int i = 0; i < index; i++) {
 913       if (t.next != null) t = t.next;
 914       else t = t.next = token_source.getNextToken();
 915     }
 916     return t;
 917   }
 918
 919   private int jj_ntk() {
 920     if ((jj_nt=token.next) == null)
 921       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
 922     else
 923       return (jj_ntk = jj_nt.kind);
 924   }
 925
 926   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
 927   private int[] jj_expentry;
 928   private int jj_kind = -1;
 929   private int[] jj_lasttokens = new int[100];
 930   private int jj_endpos;
 931
 932   private void jj_add_error_token(int kind, int pos) {
 933     if (pos >= 100) return;
 934     if (pos == jj_endpos + 1) {
 935       jj_lasttokens[jj_endpos++] = kind;
 936     } else if (jj_endpos != 0) {
 937       jj_expentry = new int[jj_endpos];
 938       for (int i = 0; i < jj_endpos; i++) {
 939         jj_expentry[i] = jj_lasttokens[i];
 940       }
 941       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
 942         int[] oldentry = (int[])(it.next());
 943         if (oldentry.length == jj_expentry.length) {
 944           for (int i = 0; i < jj_expentry.length; i++) {
 945             if (oldentry[i] != jj_expentry[i]) {
 946               continue jj_entries_loop;
 947             }
 948           }
 949           jj_expentries.add(jj_expentry);
 950           break jj_entries_loop;
 951         }
 952       }
 953       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
 954     }
 955   }
 956
 957   /** Generate ParseException. */
 958   public ParseException generateParseException() {
 959     jj_expentries.clear();
 960     boolean[] la1tokens = new boolean[47];
 961     if (jj_kind >= 0) {
 962       la1tokens[jj_kind] = true;
 963       jj_kind = -1;
 964     }
 965     for (int i = 0; i < 17; i++) {
 966       if (jj_la1[i] == jj_gen) {
 967         for (int j = 0; j < 32; j++) {
 968           if ((jj_la1_0[i] & (1<<j)) != 0) {
 969             la1tokens[j] = true;
 970           }
 971           if ((jj_la1_1[i] & (1<<j)) != 0) {
 972             la1tokens[32+j] = true;
 973           }
 974         }
 975       }
 976     }
 977     for (int i = 0; i < 47; i++) {
 978       if (la1tokens[i]) {
 979         jj_expentry = new int[1];
 980         jj_expentry[0] = i;
 981         jj_expentries.add(jj_expentry);
 982       }
 983     }
 984     jj_endpos = 0;
 985     jj_rescan_token();
 986     jj_add_error_token(0, 0);
 987     int[][] exptokseq = new int[jj_expentries.size()][];
 988     for (int i = 0; i < jj_expentries.size(); i++) {
 989       exptokseq[i] = jj_expentries.get(i);
 990     }
 991     return new ParseException(token, exptokseq, tokenImage);
 992   }
 993
 994   /** Enable tracing. */
 995   final public void enable_tracing() {
 996   }
 997
 998   /** Disable tracing. */
 999   final public void disable_tracing() {
1000   }
1001
1002   private void jj_rescan_token() {
1003     jj_rescan = true;
1004     for (int i = 0; i < 6; i++) {
1005     try {
1006       JJCalls p = jj_2_rtns[i];
1007       do {
1008         if (p.gen > jj_gen) {
1009           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1010           switch (i) {
1011             case 0: jj_3_1(); break;
1012             case 1: jj_3_2(); break;
1013             case 2: jj_3_3(); break;
1014             case 3: jj_3_4(); break;
1015             case 4: jj_3_5(); break;
1016             case 5: jj_3_6(); break;
1017           }
1018         }
1019         p = p.next;
1020       } while (p != null);
1021       } catch(LookaheadSuccess ls) { }
1022     }
1023     jj_rescan = false;
1024   }
1025
1026   private void jj_save(int index, int xla) {
1027     JJCalls p = jj_2_rtns[index];
1028     while (p.gen > jj_gen) {
1029       if (p.next == null) { p = p.next = new JJCalls(); break; }
1030       p = p.next;
1031     }
1032     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
1033   }
1034
1035   static final class JJCalls {
1036     int gen;
1037     Token first;
1038     int arg;
1039     JJCalls next;
1040   }
1041
1042 }