gerrit.simantics Code Review - simantics/sysdyn.git/blob

   1 /* XmileExpressionParser.java */
   2 /* Generated By:JavaCC: Do not edit this line. XmileExpressionParser.java */
   3 package org.simantics.sysdyn.xmile.expressionParser;
   4
   5 import java.io.StringReader;
   6 import java.lang.StringBuilder;
   7 import java.util.ArrayList;
   8 import java.util.Map;
   9
  10 import org.simantics.sysdyn.xmile.XmileUtil;
  11
  12 public class XmileExpressionParser implements XmileExpressionParserConstants {
  13   private static final boolean DEBUG = true;
  14
  15   public static String parse(String expression, Map<String, String> subscripts) {
  16     XmileExpressionParser parser = new XmileExpressionParser(new StringReader(expression));
  17
  18     try {
  19       return parser.Expression(subscripts);
  20     }
  21     catch (ParseException e) {
  22       e.printStackTrace();
  23       return null;
  24     }
  25   }
  26
  27   final public String Expression(Map<String, String> subscripts) throws ParseException {String e;
  28     e = BinExpr(subscripts);
  29     jj_consume_token(0);
  30 {if ("" != null) return e;}
  31     throw new Error("Missing return statement in function");
  32   }
  33
  34   final public String BinOp() throws ParseException {
  35     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
  36     case LOR:{
  37       jj_consume_token(LOR);
  38 {if ("" != null) return "OR";}
  39       break;
  40       }
  41     case LAND:{
  42       jj_consume_token(LAND);
  43 {if ("" != null) return "AND";}
  44       break;
  45       }
  46     case EQ:{
  47       jj_consume_token(EQ);
  48 {if ("" != null) return "=";}
  49       break;
  50       }
  51     case LT:{
  52       jj_consume_token(LT);
  53 {if ("" != null) return "<";}
  54       break;
  55       }
  56     case LEQ:{
  57       jj_consume_token(LEQ);
  58 {if ("" != null) return "<=";}
  59       break;
  60       }
  61     case GT:{
  62       jj_consume_token(GT);
  63 {if ("" != null) return ">";}
  64       break;
  65       }
  66     case GEQ:{
  67       jj_consume_token(GEQ);
  68 {if ("" != null) return ">=";}
  69       break;
  70       }
  71     case PLUS:{
  72       jj_consume_token(PLUS);
  73 {if ("" != null) return "+";}
  74       break;
  75       }
  76     case MINUS:{
  77       jj_consume_token(MINUS);
  78 {if ("" != null) return "-";}
  79       break;
  80       }
  81     case MULT:{
  82       jj_consume_token(MULT);
  83 {if ("" != null) return "*";}
  84       break;
  85       }
  86     case DIV:{
  87       jj_consume_token(DIV);
  88 {if ("" != null) return "/";}
  89       break;
  90       }
  91     case MOD:{
  92       jj_consume_token(MOD);
  93 {if ("" != null) return "%";}
  94       break;
  95       }
  96     default:
  97       jj_la1[0] = jj_gen;
  98       jj_consume_token(-1);
  99       throw new ParseException();
 100     }
 101     throw new Error("Missing return statement in function");
 102   }
 103
 104   final public String BinExpr(Map<String, String> subscripts) throws ParseException {String l = null;
 105   String o = null;
 106   String r = null;
 107     l = UnExpr(subscripts);
 108     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 109     case LOR:
 110     case LAND:
 111     case EQ:
 112     case LT:
 113     case LEQ:
 114     case GT:
 115     case GEQ:
 116     case PLUS:
 117     case MINUS:
 118     case MULT:
 119     case DIV:
 120     case MOD:{
 121       o = BinOp();
 122       r = BinExpr(subscripts);
 123       break;
 124       }
 125     default:
 126       jj_la1[1] = jj_gen;
 127       ;
 128     }
 129 {if ("" != null) return o != null ? l + o + r : l;}
 130     throw new Error("Missing return statement in function");
 131   }
 132
 133   final public String UnOp() throws ParseException {
 134     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 135     case LNOT:{
 136       jj_consume_token(LNOT);
 137 {if ("" != null) return "NOT";}
 138       break;
 139       }
 140     case PLUS:{
 141       jj_consume_token(PLUS);
 142 {if ("" != null) return "+";}
 143       break;
 144       }
 145     case MINUS:{
 146       jj_consume_token(MINUS);
 147 {if ("" != null) return "-";}
 148       break;
 149       }
 150     default:
 151       jj_la1[2] = jj_gen;
 152       jj_consume_token(-1);
 153       throw new ParseException();
 154     }
 155     throw new Error("Missing return statement in function");
 156   }
 157
 158   final public String UnExpr(Map<String, String> subscripts) throws ParseException {String o = null;
 159   String e = null;
 160     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 161     case LNOT:
 162     case PLUS:
 163     case MINUS:{
 164       o = UnOp();
 165       break;
 166       }
 167     default:
 168       jj_la1[3] = jj_gen;
 169       ;
 170     }
 171     e = Atom(subscripts);
 172 {if ("" != null) return o != null ? o + e : e;}
 173     throw new Error("Missing return statement in function");
 174   }
 175
 176   final public String Atom(Map<String, String> subscripts) throws ParseException {Token t = null;
 177   String s = null;
 178     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 179     case NUMBER:{
 180       t = jj_consume_token(NUMBER);
 181 {if ("" != null) return t.image;}
 182       break;
 183       }
 184     default:
 185       jj_la1[4] = jj_gen;
 186       if (jj_2_1(2)) {
 187         s = Function(subscripts);
 188 {if ("" != null) return s;}
 189       } else {
 190         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 191         case IDENT:
 192         case QIDENT:{
 193           s = Variable(subscripts);
 194 {if ("" != null) return s;}
 195           break;
 196           }
 197         case LPAREN:{
 198           jj_consume_token(LPAREN);
 199           s = BinExpr(subscripts);
 200           jj_consume_token(RPAREN);
 201 {if ("" != null) return "(" + s + ")";}
 202           break;
 203           }
 204         default:
 205           jj_la1[5] = jj_gen;
 206           jj_consume_token(-1);
 207           throw new ParseException();
 208         }
 209       }
 210     }
 211     throw new Error("Missing return statement in function");
 212   }
 213
 214   final public String Function(Map<String, String> subscripts) throws ParseException {Token t = null;
 215   String p = null;
 216   ArrayList<String> params = new ArrayList<String>();
 217     t = jj_consume_token(IDENT);
 218     jj_consume_token(LPAREN);
 219     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 220     case LNOT:
 221     case PLUS:
 222     case MINUS:
 223     case LPAREN:
 224     case NUMBER:
 225     case IDENT:
 226     case QIDENT:{
 227       p = BinExpr(subscripts);
 228 params.add(p);
 229       label_1:
 230       while (true) {
 231         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 232         case COMMA:{
 233           ;
 234           break;
 235           }
 236         default:
 237           jj_la1[6] = jj_gen;
 238           break label_1;
 239         }
 240         jj_consume_token(COMMA);
 241         p = BinExpr(subscripts);
 242 params.add(p);
 243       }
 244       break;
 245       }
 246     default:
 247       jj_la1[7] = jj_gen;
 248       ;
 249     }
 250     jj_consume_token(RPAREN);
 251 String name = XmileUtil.getSysdynFunction(t.image);
 252     StringBuilder f = new StringBuilder();
 253     f.append(XmileUtil.FUNCTION_PREFIX);
 254     f.append(name);
 255     f.append('(');
 256     for (int i = 0; i < params.size(); i++) {
 257       if (i > 0) f.append(',');
 258       f.append(params.get(i));
 259     }
 260     if (XmileUtil.needsTime(name)) {
 261       f.append(XmileUtil.TIME_PARAM);
 262     }
 263     if (XmileUtil.needsTimeStep(name)) {
 264       f.append(XmileUtil.TIME_STEP_PARAM);
 265     }
 266     if (XmileUtil.needsTimeStart(name)) {
 267       f.append(XmileUtil.TIME_START_PARAM);
 268     }
 269     if (XmileUtil.needsTimeStop(name)) {
 270       f.append(XmileUtil.TIME_STOP_PARAM);
 271     }
 272     f.append(')');
 273     {if ("" != null) return f.toString();}
 274     throw new Error("Missing return statement in function");
 275   }
 276
 277   final public String Variable(Map<String, String> subscripts) throws ParseException {Token t = null;
 278     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 279     case IDENT:{
 280       t = jj_consume_token(IDENT);
 281 {if ("" != null) return XmileUtil.normalize(t.image);}
 282       break;
 283       }
 284     case QIDENT:{
 285       t = jj_consume_token(QIDENT);
 286 {if ("" != null) return t.image;}
 287       break;
 288       }
 289     default:
 290       jj_la1[8] = jj_gen;
 291       jj_consume_token(-1);
 292       throw new ParseException();
 293     }
 294     throw new Error("Missing return statement in function");
 295   }
 296
 297   private boolean jj_2_1(int xla)
 298  {
 299     jj_la = xla; jj_lastpos = jj_scanpos = token;
 300     try { return !jj_3_1(); }
 301     catch(LookaheadSuccess ls) { return true; }
 302     finally { jj_save(0, xla); }
 303   }
 304
 305   private boolean jj_3R_2()
 306  {
 307     if (jj_scan_token(IDENT)) return true;
 308     if (jj_scan_token(LPAREN)) return true;
 309     return false;
 310   }
 311
 312   private boolean jj_3_1()
 313  {
 314     if (jj_3R_2()) return true;
 315     return false;
 316   }
 317
 318   /** Generated Token Manager. */
 319   public XmileExpressionParserTokenManager token_source;
 320   SimpleCharStream jj_input_stream;
 321   /** Current token. */
 322   public Token token;
 323   /** Next token. */
 324   public Token jj_nt;
 325   private int jj_ntk;
 326   private Token jj_scanpos, jj_lastpos;
 327   private int jj_la;
 328   private int jj_gen;
 329   final private int[] jj_la1 = new int[9];
 330   static private int[] jj_la1_0;
 331   static {
 332       jj_la1_init_0();
 333    }
 334    private static void jj_la1_init_0() {
 335       jj_la1_0 = new int[] {0x7fec,0x7fec,0xc10,0xc10,0x80000,0x310000,0x40000,0x390c10,0x300000,};
 336    }
 337   final private JJCalls[] jj_2_rtns = new JJCalls[1];
 338   private boolean jj_rescan = false;
 339   private int jj_gc = 0;
 340
 341   /** Constructor with InputStream. */
 342   public XmileExpressionParser(java.io.InputStream stream) {
 343      this(stream, null);
 344   }
 345   /** Constructor with InputStream and supplied encoding */
 346   public XmileExpressionParser(java.io.InputStream stream, String encoding) {
 347     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
 348     token_source = new XmileExpressionParserTokenManager(jj_input_stream);
 349     token = new Token();
 350     jj_ntk = -1;
 351     jj_gen = 0;
 352     for (int i = 0; i < 9; i++) jj_la1[i] = -1;
 353     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 354   }
 355
 356   /** Reinitialise. */
 357   public void ReInit(java.io.InputStream stream) {
 358      ReInit(stream, null);
 359   }
 360   /** Reinitialise. */
 361   public void ReInit(java.io.InputStream stream, String encoding) {
 362     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
 363     token_source.ReInit(jj_input_stream);
 364     token = new Token();
 365     jj_ntk = -1;
 366     jj_gen = 0;
 367     for (int i = 0; i < 9; i++) jj_la1[i] = -1;
 368     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 369   }
 370
 371   /** Constructor. */
 372   public XmileExpressionParser(java.io.Reader stream) {
 373     jj_input_stream = new SimpleCharStream(stream, 1, 1);
 374     token_source = new XmileExpressionParserTokenManager(jj_input_stream);
 375     token = new Token();
 376     jj_ntk = -1;
 377     jj_gen = 0;
 378     for (int i = 0; i < 9; i++) jj_la1[i] = -1;
 379     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 380   }
 381
 382   /** Reinitialise. */
 383   public void ReInit(java.io.Reader stream) {
 384     jj_input_stream.ReInit(stream, 1, 1);
 385     token_source.ReInit(jj_input_stream);
 386     token = new Token();
 387     jj_ntk = -1;
 388     jj_gen = 0;
 389     for (int i = 0; i < 9; i++) jj_la1[i] = -1;
 390     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 391   }
 392
 393   /** Constructor with generated Token Manager. */
 394   public XmileExpressionParser(XmileExpressionParserTokenManager tm) {
 395     token_source = tm;
 396     token = new Token();
 397     jj_ntk = -1;
 398     jj_gen = 0;
 399     for (int i = 0; i < 9; i++) jj_la1[i] = -1;
 400     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 401   }
 402
 403   /** Reinitialise. */
 404   public void ReInit(XmileExpressionParserTokenManager tm) {
 405     token_source = tm;
 406     token = new Token();
 407     jj_ntk = -1;
 408     jj_gen = 0;
 409     for (int i = 0; i < 9; i++) jj_la1[i] = -1;
 410     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 411   }
 412
 413   private Token jj_consume_token(int kind) throws ParseException {
 414     Token oldToken;
 415     if ((oldToken = token).next != null) token = token.next;
 416     else token = token.next = token_source.getNextToken();
 417     jj_ntk = -1;
 418     if (token.kind == kind) {
 419       jj_gen++;
 420       if (++jj_gc > 100) {
 421         jj_gc = 0;
 422         for (int i = 0; i < jj_2_rtns.length; i++) {
 423           JJCalls c = jj_2_rtns[i];
 424           while (c != null) {
 425             if (c.gen < jj_gen) c.first = null;
 426             c = c.next;
 427           }
 428         }
 429       }
 430       return token;
 431     }
 432     token = oldToken;
 433     jj_kind = kind;
 434     throw generateParseException();
 435   }
 436
 437   @SuppressWarnings("serial")
 438   static private final class LookaheadSuccess extends java.lang.Error { }
 439   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
 440   private boolean jj_scan_token(int kind) {
 441     if (jj_scanpos == jj_lastpos) {
 442       jj_la--;
 443       if (jj_scanpos.next == null) {
 444         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
 445       } else {
 446         jj_lastpos = jj_scanpos = jj_scanpos.next;
 447       }
 448     } else {
 449       jj_scanpos = jj_scanpos.next;
 450     }
 451     if (jj_rescan) {
 452       int i = 0; Token tok = token;
 453       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
 454       if (tok != null) jj_add_error_token(kind, i);
 455     }
 456     if (jj_scanpos.kind != kind) return true;
 457     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
 458     return false;
 459   }
 460
 461
 462 /** Get the next Token. */
 463   final public Token getNextToken() {
 464     if (token.next != null) token = token.next;
 465     else token = token.next = token_source.getNextToken();
 466     jj_ntk = -1;
 467     jj_gen++;
 468     return token;
 469   }
 470
 471 /** Get the specific Token. */
 472   final public Token getToken(int index) {
 473     Token t = token;
 474     for (int i = 0; i < index; i++) {
 475       if (t.next != null) t = t.next;
 476       else t = t.next = token_source.getNextToken();
 477     }
 478     return t;
 479   }
 480
 481   private int jj_ntk_f() {
 482     if ((jj_nt=token.next) == null)
 483       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
 484     else
 485       return (jj_ntk = jj_nt.kind);
 486   }
 487
 488   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
 489   private int[] jj_expentry;
 490   private int jj_kind = -1;
 491   private int[] jj_lasttokens = new int[100];
 492   private int jj_endpos;
 493
 494   private void jj_add_error_token(int kind, int pos) {
 495     if (pos >= 100) return;
 496     if (pos == jj_endpos + 1) {
 497       jj_lasttokens[jj_endpos++] = kind;
 498     } else if (jj_endpos != 0) {
 499       jj_expentry = new int[jj_endpos];
 500       for (int i = 0; i < jj_endpos; i++) {
 501         jj_expentry[i] = jj_lasttokens[i];
 502       }
 503       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
 504         int[] oldentry = (int[])(it.next());
 505         if (oldentry.length == jj_expentry.length) {
 506           for (int i = 0; i < jj_expentry.length; i++) {
 507             if (oldentry[i] != jj_expentry[i]) {
 508               continue jj_entries_loop;
 509             }
 510           }
 511           jj_expentries.add(jj_expentry);
 512           break jj_entries_loop;
 513         }
 514       }
 515       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
 516     }
 517   }
 518
 519   /** Generate ParseException. */
 520   public ParseException generateParseException() {
 521     jj_expentries.clear();
 522     boolean[] la1tokens = new boolean[22];
 523     if (jj_kind >= 0) {
 524       la1tokens[jj_kind] = true;
 525       jj_kind = -1;
 526     }
 527     for (int i = 0; i < 9; i++) {
 528       if (jj_la1[i] == jj_gen) {
 529         for (int j = 0; j < 32; j++) {
 530           if ((jj_la1_0[i] & (1<<j)) != 0) {
 531             la1tokens[j] = true;
 532           }
 533         }
 534       }
 535     }
 536     for (int i = 0; i < 22; i++) {
 537       if (la1tokens[i]) {
 538         jj_expentry = new int[1];
 539         jj_expentry[0] = i;
 540         jj_expentries.add(jj_expentry);
 541       }
 542     }
 543     jj_endpos = 0;
 544     jj_rescan_token();
 545     jj_add_error_token(0, 0);
 546     int[][] exptokseq = new int[jj_expentries.size()][];
 547     for (int i = 0; i < jj_expentries.size(); i++) {
 548       exptokseq[i] = jj_expentries.get(i);
 549     }
 550     return new ParseException(token, exptokseq, tokenImage);
 551   }
 552
 553   /** Enable tracing. */
 554   final public void enable_tracing() {
 555   }
 556
 557   /** Disable tracing. */
 558   final public void disable_tracing() {
 559   }
 560
 561   private void jj_rescan_token() {
 562     jj_rescan = true;
 563     for (int i = 0; i < 1; i++) {
 564     try {
 565       JJCalls p = jj_2_rtns[i];
 566       do {
 567         if (p.gen > jj_gen) {
 568           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
 569           switch (i) {
 570             case 0: jj_3_1(); break;
 571           }
 572         }
 573         p = p.next;
 574       } while (p != null);
 575       } catch(LookaheadSuccess ls) { }
 576     }
 577     jj_rescan = false;
 578   }
 579
 580   private void jj_save(int index, int xla) {
 581     JJCalls p = jj_2_rtns[index];
 582     while (p.gen > jj_gen) {
 583       if (p.next == null) { p = p.next = new JJCalls(); break; }
 584       p = p.next;
 585     }
 586     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
 587   }
 588
 589   static final class JJCalls {
 590     int gen;
 591     Token first;
 592     int arg;
 593     JJCalls next;
 594   }
 595
 596 }