2 import MCC.IR.ParseNode;
3 import MCC.IR.ParseNodeVector;
8 public static boolean errors;
9 public static boolean debug;
11 // debugMessage: writes debug production message only if debug = true
13 void debugMessage (String production) {
15 System.out.println("Applying production: " + production);
19 String unescape (String str) {
20 StringBuffer sb = new StringBuffer();
22 // Note that we skip the first and last characters (they're "'s)
23 for (i = 1; i < str.length() - 1; i++) {
24 if (str.charAt(i) == '\\') {
26 switch (str.charAt(i)) {
43 System.err.print("Error in string literal: ");
44 System.err.println(str.charAt(i));
45 System.err.println("Aborting...");
49 sb.append(str.charAt(i));
60 public String filename;
62 public void syntax_error (java_cup.runtime.Symbol current) {
64 CUP$MDLParser$actions.errors = true;
65 Symbol symbol = (Symbol) current;
67 //System.out.println("current.value = "+current.value + " " + current.value.equals("true"));
68 //System.out.println("current = " + current);
70 boolean isInteger = true;
72 Integer.parseInt(current.value.toString());
73 } catch(NumberFormatException e) { isInteger = false;}
75 report_error(filename+":"+(symbol.line+1)+": Syntax error at column "
76 + (LineCount.getColumn(symbol.left)+1) +": " + current.value, current);
79 if (current.value.equals("true") || isInteger)
80 System.out.println("Did you mean literal("+current.value+")?");
83 if (LineCount.getColumn(symbol.left) == 0)
84 System.out.println("Did you forget a semicolon on the previous line?");
91 public void report_fatal_error (String message, Object info) {
94 report_error(message, info);
95 CUP$MDLParser$actions.errors = true;
98 public int curPos () {
99 return cur_token.left;
102 public int curLine (int back) {
103 Stack st = new Stack();
106 for (i = 0; i < back; i++) {
107 st.push(stack.pop());
110 java_cup.runtime.Symbol s;
111 s = (java_cup.runtime.Symbol) st.peek();
113 for (i = 0; i < back; i++) {
114 stack.push(st.pop());
117 return LineCount.getLine(s.left);
122 // TERMINALS /////////////////////////////////////////////////////////////
127 terminal String DECIMAL;
128 terminal String CHAR;
129 terminal String STRING;
135 terminal OPENBRACKET;
136 terminal CLOSEBRACKET;
204 // NON-TERMINALS /////////////////////////////////////////////////////////
208 ------------------------------------------------------------------------*/
210 nonterminal ParseNode rules;
211 nonterminal ParseNode rule;
212 nonterminal ParseNode ruletype;
213 nonterminal ParseNode optquantifiers;
214 nonterminal ParseNode quantifiers;
215 nonterminal ParseNode quantifier;
216 nonterminal ParseNode inclusion;
217 nonterminal ParseNode expr;
218 nonterminal ParseNode literal;
220 nonterminal ParseNode simple_expr;
221 nonterminal ParseNode location;
223 nonterminal ParseNode set;
224 nonterminal ParseNode listofliterals;
226 precedence nonassoc OR;
227 precedence nonassoc AND;
229 precedence nonassoc EQ, NE;
230 precedence nonassoc LT, LE, GE, GT;
232 precedence left INTEST;
234 precedence left ADD, SUB;
235 precedence left MULT, DIV;
239 // PRODUCTION RULES /////////////////////////////////////////////////////
245 rules:rules rule:rule
247 debugMessage(PRODSTRING);
248 rules.addChild(rule);
254 debugMessage(PRODSTRING);
255 ParseNode rules = new ParseNode("rules", parser.curLine(1));
256 rules.addChild(rule);
263 ruletype:ruletype OPENBRACKET optquantifiers:quantifiers CLOSEBRACKET
264 COMMA expr:guard IMPLIES inclusion:inclusion SEMICOLON
266 debugMessage(PRODSTRING);
267 ParseNode rule = new ParseNode("rule", parser.curLine(9));
268 if (ruletype != null) {
269 rule.addChild(ruletype);
271 if (quantifiers != null) {
272 rule.addChild(quantifiers);
274 rule.addChild(guard);
275 rule.addChild(inclusion);
284 debugMessage(PRODSTRING);
285 RESULT = new ParseNode("static", parser.curLine(1));
290 debugMessage(PRODSTRING);
291 RESULT = new ParseNode("delay", parser.curLine(1));
296 debugMessage(PRODSTRING);
303 quantifiers:quantifiers
305 debugMessage(PRODSTRING);
306 RESULT = quantifiers;
311 debugMessage(PRODSTRING);
318 quantifiers:quantifiers COMMA quantifier:quantifier
320 debugMessage(PRODSTRING);
321 quantifiers.addChild(quantifier);
322 RESULT = quantifiers;
325 | quantifier:quantifier
327 debugMessage(PRODSTRING);
328 ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
329 quantifiers.addChild(quantifier);
330 RESULT = quantifiers;
336 FORALL ID:var IN set:set
338 debugMessage(PRODSTRING);
339 ParseNode q = new ParseNode("quantifier", parser.curLine(4));
340 q.addChild("forall", parser.curLine(4));
341 q.addChild("var", parser.curLine(3)).addChild(var);
346 | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
348 debugMessage(PRODSTRING);
349 ParseNode q = new ParseNode("quantifier", parser.curLine(7));
350 q.addChild("relation", parser.curLine(1)).addChild(relation);
351 q.addChild("left", parser.curLine(5)).addChild(r1);
352 q.addChild("right", parser.curLine(3)).addChild(r2);
356 | FOR ID:var EQ expr:lower TO expr:upper
358 debugMessage(PRODSTRING);
359 ParseNode q = new ParseNode("quantifier", parser.curLine(5));
361 q.addChild("var", parser.curLine(4)).addChild(var);
362 q.addChild("lower", parser.curLine(3)).addChild(lower);
363 q.addChild("upper", parser.curLine(1)).addChild(upper);
370 expr:expr IN ID:setname
372 debugMessage(PRODSTRING);
373 ParseNode set = (new ParseNode("inclusion", parser.curLine(3))).addChild("set");
375 set.addChild("name", parser.curLine(1)).addChild(setname);
376 RESULT = set.getRoot();
379 | LT expr:r1 COMMA expr:r2 GT IN ID:relationname
381 debugMessage(PRODSTRING);
382 ParseNode relation = (new ParseNode("inclusion", parser.curLine(7))).addChild("relation");
383 relation.addChild("left").addChild(r1);
384 relation.addChild("right").addChild(r2);
385 relation.addChild("name", parser.curLine(1)).addChild(relationname);
386 RESULT = relation.getRoot();
394 debugMessage(PRODSTRING);
395 ParseNode se = new ParseNode("simple_expr", parser.curLine(1));
396 se.addChild(location);
405 debugMessage(PRODSTRING);
406 ParseNode loc = new ParseNode("location", parser.curLine(1));
407 loc.addChild("var").addChild(var);
411 | simple_expr:dotexpr DOT ID:field
413 debugMessage(PRODSTRING);
414 ParseNode dot = (new ParseNode("location", parser.curLine(3))).addChild("dot");
415 dot.addChild(dotexpr);
416 dot.addChild("field", parser.curLine(1)).addChild(field);
417 RESULT = dot.getRoot();
420 | simple_expr:dotexpr DOT ID:field OPENBRACKET expr:index CLOSEBRACKET
422 debugMessage(PRODSTRING);
423 ParseNode dot = (new ParseNode("location", parser.curLine(6))).addChild("dot");
424 dot.addChild(dotexpr);
425 dot.addChild("field", parser.curLine(4)).addChild(field);
426 dot.addChild("index", parser.curLine(2)).addChild(index);
427 RESULT = dot.getRoot();
430 | CAST OPENPAREN ID:type COMMA simple_expr:expr CLOSEPAREN
432 debugMessage(PRODSTRING);
433 ParseNode cast = (new ParseNode("location", parser.curLine(6))).addChild("cast");
434 cast.addChild("type").addChild(type);
436 RESULT = cast.getRoot();
444 debugMessage(PRODSTRING);
445 ParseNode expr = new ParseNode("expr", parser.curLine(1));
450 | expr:expr INTEST ID:setname
452 debugMessage(PRODSTRING);
453 ParseNode elementof = (new ParseNode("expr", parser.curLine(3))).addChild("elementof");
454 elementof.addChild(expr);
455 elementof.addChild("name").addChild(setname);
456 RESULT = elementof.getRoot();
459 | LT expr:r1 COMMA expr:r2 GT INTEST ID:relationname
461 debugMessage(PRODSTRING);
462 ParseNode tupleof = (new ParseNode("expr", parser.curLine(7))).addChild("tupleof");
463 tupleof.addChild("left").addChild(r1);
464 tupleof.addChild("right").addChild(r2);
465 tupleof.addChild("name").addChild(relationname);
466 RESULT = tupleof.getRoot();
469 | OPENPAREN expr:expr CLOSEPAREN
471 debugMessage(PRODSTRING);
477 debugMessage(PRODSTRING);
478 ParseNode expr = new ParseNode("expr", parser.curLine(4));
479 expr.addChild(literal);
484 | expr:leftexpr LT expr:rightexpr
486 debugMessage(PRODSTRING);
487 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
488 bool.addChild("op").addChild("lt");
489 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
490 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
491 RESULT = bool.getRoot();
494 | expr:leftexpr LE expr:rightexpr
496 debugMessage(PRODSTRING);
497 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
498 bool.addChild("op").addChild("le");
499 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
500 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
501 RESULT = bool.getRoot();
504 | expr:leftexpr GT expr:rightexpr
506 debugMessage(PRODSTRING);
507 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
508 bool.addChild("op").addChild("gt");
509 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
510 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
511 RESULT = bool.getRoot();
514 | expr:leftexpr GE expr:rightexpr
516 debugMessage(PRODSTRING);
517 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
518 bool.addChild("op").addChild("ge");
519 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
520 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
521 RESULT = bool.getRoot();
524 | expr:leftexpr EQ expr:rightexpr
526 debugMessage(PRODSTRING);
527 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
528 bool.addChild("op").addChild("eq");
529 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
530 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
531 RESULT = bool.getRoot();
534 | expr:leftexpr NE expr:rightexpr
536 debugMessage(PRODSTRING);
537 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
538 bool.addChild("op").addChild("ne");
539 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
540 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
541 RESULT = bool.getRoot();
544 | expr:leftexpr ADD expr:rightexpr
546 debugMessage(PRODSTRING);
547 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
548 bool.addChild("op").addChild("add");
549 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
550 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
551 RESULT = bool.getRoot();
554 | expr:leftexpr SUB expr:rightexpr
556 debugMessage(PRODSTRING);
557 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
558 bool.addChild("op").addChild("sub");
559 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
560 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
561 RESULT = bool.getRoot();
564 | expr:leftexpr DIV expr:rightexpr
566 debugMessage(PRODSTRING);
567 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
568 bool.addChild("op").addChild("div");
569 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
570 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
571 RESULT = bool.getRoot();
574 | expr:leftexpr MULT expr:rightexpr
576 debugMessage(PRODSTRING);
577 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
578 bool.addChild("op").addChild("mult");
579 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
580 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
581 RESULT = bool.getRoot();
584 | expr:leftexpr AND expr:rightexpr
586 debugMessage(PRODSTRING);
587 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
588 bool.addChild("op").addChild("and");
589 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
590 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
591 RESULT = bool.getRoot();
594 | expr:leftexpr OR expr:rightexpr
596 debugMessage(PRODSTRING);
597 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
598 bool.addChild("op").addChild("or");
599 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
600 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
601 RESULT = bool.getRoot();
606 debugMessage(PRODSTRING);
607 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
608 bool.addChild("op").addChild("not");
609 bool.addChild("left").addChild(expr);
610 RESULT = bool.getRoot();
613 | ISVALID OPENPAREN expr:innerexpr CLOSEPAREN
615 debugMessage(PRODSTRING);
616 ParseNode expr = new ParseNode("expr", parser.curLine(4));
617 expr.addChild("isvalid").addChild(innerexpr);
621 | ISVALID OPENPAREN expr:innerexpr COMMA ID:type CLOSEPAREN
623 debugMessage(PRODSTRING);
624 ParseNode isvalid = (new ParseNode("expr", parser.curLine(6))).addChild("isvalid");
625 isvalid.addChild(innerexpr);
626 isvalid.addChild("type", parser.curLine(2)).addChild(type);
627 RESULT = isvalid.getRoot();
631 /** standard *********************************/
637 debugMessage(PRODSTRING);
638 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
643 debugMessage(PRODSTRING);
644 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
649 debugMessage(PRODSTRING);
650 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild("0").getRoot();
655 debugMessage(PRODSTRING);
656 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
661 debugMessage(PRODSTRING);
662 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild("-"+dec).getRoot();
667 debugMessage(PRODSTRING);
668 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
673 debugMessage(PRODSTRING);
674 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
677 | LITERAL OPENPAREN ID:literal CLOSEPAREN
679 debugMessage(PRODSTRING);
680 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();
688 debugMessage(PRODSTRING);
689 ParseNode set = new ParseNode("set", parser.curLine(1));
690 set.addChild("name").addChild(setname);
694 | OPENBRACE listofliterals:list CLOSEBRACE
696 debugMessage(PRODSTRING);
697 ParseNode set = new ParseNode("set", parser.curLine(3));
706 listofliterals:list COMMA literal:literal
708 debugMessage(PRODSTRING);
709 list.addChild(literal);
715 debugMessage(PRODSTRING);
716 ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
717 list.addChild(literal);