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);
78 if (current.value.equals("true") || isInteger)
79 System.out.println("Did you mean literal("+current.value+")?");
81 if (LineCount.getColumn(symbol.left) == 0)
82 System.out.println("Did you forget a semicolon on the previous line?");
89 public void report_fatal_error (String message, Object info) {
92 report_error(message, info);
93 CUP$MDLParser$actions.errors = true;
96 public int curPos () {
97 return cur_token.left;
100 public int curLine (int back) {
101 Stack st = new Stack();
104 for (i = 0; i < back; i++) {
105 st.push(stack.pop());
108 java_cup.runtime.Symbol s;
109 s = (java_cup.runtime.Symbol) st.peek();
111 for (i = 0; i < back; i++) {
112 stack.push(st.pop());
115 return LineCount.getLine(s.left);
120 // TERMINALS /////////////////////////////////////////////////////////////
125 terminal String DECIMAL;
126 terminal String CHAR;
127 terminal String STRING;
133 terminal OPENBRACKET;
134 terminal CLOSEBRACKET;
200 // NON-TERMINALS /////////////////////////////////////////////////////////
204 ------------------------------------------------------------------------*/
206 nonterminal ParseNode rules;
207 nonterminal ParseNode rule;
208 nonterminal ParseNode ruletype;
209 nonterminal ParseNode optquantifiers;
210 nonterminal ParseNode quantifiers;
211 nonterminal ParseNode quantifier;
212 nonterminal ParseNode inclusion;
213 nonterminal ParseNode expr;
214 nonterminal ParseNode literal;
216 nonterminal ParseNode simple_expr;
217 nonterminal ParseNode location;
219 nonterminal ParseNode set;
220 nonterminal ParseNode listofliterals;
222 precedence nonassoc OR;
223 precedence nonassoc AND;
225 precedence nonassoc EQ, NE;
226 precedence nonassoc LT, LE, GE, GT;
228 precedence left INTEST;
230 precedence left ADD, SUB;
231 precedence left MULT, DIV;
235 // PRODUCTION RULES /////////////////////////////////////////////////////
241 rules:rules rule:rule
243 debugMessage(PRODSTRING);
244 rules.addChild(rule);
250 debugMessage(PRODSTRING);
251 ParseNode rules = new ParseNode("rules", parser.curLine(1));
252 rules.addChild(rule);
259 ruletype:ruletype OPENBRACKET optquantifiers:quantifiers CLOSEBRACKET
260 COMMA expr:guard IMPLIES inclusion:inclusion SEMICOLON
262 debugMessage(PRODSTRING);
263 ParseNode rule = new ParseNode("rule", parser.curLine(9));
264 if (ruletype != null) {
265 rule.addChild(ruletype);
267 if (quantifiers != null) {
268 rule.addChild(quantifiers);
270 rule.addChild(guard);
271 rule.addChild(inclusion);
280 debugMessage(PRODSTRING);
281 RESULT = new ParseNode("static", parser.curLine(1));
286 debugMessage(PRODSTRING);
287 RESULT = new ParseNode("delay", parser.curLine(1));
292 debugMessage(PRODSTRING);
299 quantifiers:quantifiers
301 debugMessage(PRODSTRING);
302 RESULT = quantifiers;
307 debugMessage(PRODSTRING);
314 quantifiers:quantifiers COMMA quantifier:quantifier
316 debugMessage(PRODSTRING);
317 quantifiers.addChild(quantifier);
318 RESULT = quantifiers;
321 | quantifier:quantifier
323 debugMessage(PRODSTRING);
324 ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
325 quantifiers.addChild(quantifier);
326 RESULT = quantifiers;
332 FORALL ID:var IN set:set
334 debugMessage(PRODSTRING);
335 ParseNode q = new ParseNode("quantifier", parser.curLine(4));
336 q.addChild("forall", parser.curLine(4));
337 q.addChild("var", parser.curLine(3)).addChild(var);
342 | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
344 debugMessage(PRODSTRING);
345 ParseNode q = new ParseNode("quantifier", parser.curLine(7));
346 q.addChild("relation", parser.curLine(1)).addChild(relation);
347 q.addChild("left", parser.curLine(5)).addChild(r1);
348 q.addChild("right", parser.curLine(3)).addChild(r2);
352 | FOR ID:var EQ expr:lower TO expr:upper
354 debugMessage(PRODSTRING);
355 ParseNode q = new ParseNode("quantifier", parser.curLine(5));
357 q.addChild("var", parser.curLine(4)).addChild(var);
358 q.addChild("lower", parser.curLine(3)).addChild(lower);
359 q.addChild("upper", parser.curLine(1)).addChild(upper);
366 expr:expr IN ID:setname
368 debugMessage(PRODSTRING);
369 ParseNode set = (new ParseNode("inclusion", parser.curLine(3))).addChild("set");
371 set.addChild("name", parser.curLine(1)).addChild(setname);
372 RESULT = set.getRoot();
375 | LT expr:r1 COMMA expr:r2 GT IN ID:relationname
377 debugMessage(PRODSTRING);
378 ParseNode relation = (new ParseNode("inclusion", parser.curLine(7))).addChild("relation");
379 relation.addChild("left").addChild(r1);
380 relation.addChild("right").addChild(r2);
381 relation.addChild("name", parser.curLine(1)).addChild(relationname);
382 RESULT = relation.getRoot();
390 debugMessage(PRODSTRING);
391 ParseNode se = new ParseNode("simple_expr", parser.curLine(1));
392 se.addChild(location);
401 debugMessage(PRODSTRING);
402 ParseNode loc = new ParseNode("location", parser.curLine(1));
403 loc.addChild("var").addChild(var);
407 | simple_expr:dotexpr DOT ID:field
409 debugMessage(PRODSTRING);
410 ParseNode dot = (new ParseNode("location", parser.curLine(3))).addChild("dot");
411 dot.addChild(dotexpr);
412 dot.addChild("field", parser.curLine(1)).addChild(field);
413 RESULT = dot.getRoot();
416 | simple_expr:dotexpr DOT ID:field OPENBRACKET expr:index CLOSEBRACKET
418 debugMessage(PRODSTRING);
419 ParseNode dot = (new ParseNode("location", parser.curLine(6))).addChild("dot");
420 dot.addChild(dotexpr);
421 dot.addChild("field", parser.curLine(4)).addChild(field);
422 dot.addChild("index", parser.curLine(2)).addChild(index);
423 RESULT = dot.getRoot();
426 | CAST OPENPAREN ID:type COMMA simple_expr:expr CLOSEPAREN
428 debugMessage(PRODSTRING);
429 ParseNode cast = (new ParseNode("location", parser.curLine(6))).addChild("cast");
430 cast.addChild("type").addChild(type);
432 RESULT = cast.getRoot();
440 debugMessage(PRODSTRING);
441 ParseNode expr = new ParseNode("expr", parser.curLine(1));
446 | expr:expr INTEST ID:setname
448 debugMessage(PRODSTRING);
449 ParseNode elementof = (new ParseNode("expr", parser.curLine(3))).addChild("elementof");
450 elementof.addChild(expr);
451 elementof.addChild("name").addChild(setname);
452 RESULT = elementof.getRoot();
455 | LT expr:r1 COMMA expr:r2 GT INTEST ID:relationname
457 debugMessage(PRODSTRING);
458 ParseNode tupleof = (new ParseNode("expr", parser.curLine(7))).addChild("tupleof");
459 tupleof.addChild("left").addChild(r1);
460 tupleof.addChild("right").addChild(r2);
461 tupleof.addChild("name").addChild(relationname);
462 RESULT = tupleof.getRoot();
465 | OPENPAREN expr:expr CLOSEPAREN
467 debugMessage(PRODSTRING);
471 | LITERAL OPENPAREN literal:literal CLOSEPAREN
473 debugMessage(PRODSTRING);
474 ParseNode expr = new ParseNode("expr", parser.curLine(4));
475 expr.addChild(literal);
479 | expr:leftexpr LT expr:rightexpr
481 debugMessage(PRODSTRING);
482 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
483 bool.addChild("op").addChild("lt");
484 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
485 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
486 RESULT = bool.getRoot();
489 | expr:leftexpr LE expr:rightexpr
491 debugMessage(PRODSTRING);
492 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
493 bool.addChild("op").addChild("le");
494 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
495 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
496 RESULT = bool.getRoot();
499 | expr:leftexpr GT expr:rightexpr
501 debugMessage(PRODSTRING);
502 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
503 bool.addChild("op").addChild("gt");
504 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
505 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
506 RESULT = bool.getRoot();
509 | expr:leftexpr GE expr:rightexpr
511 debugMessage(PRODSTRING);
512 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
513 bool.addChild("op").addChild("ge");
514 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
515 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
516 RESULT = bool.getRoot();
519 | expr:leftexpr EQ expr:rightexpr
521 debugMessage(PRODSTRING);
522 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
523 bool.addChild("op").addChild("eq");
524 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
525 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
526 RESULT = bool.getRoot();
529 | expr:leftexpr NE expr:rightexpr
531 debugMessage(PRODSTRING);
532 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
533 bool.addChild("op").addChild("ne");
534 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
535 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
536 RESULT = bool.getRoot();
539 | expr:leftexpr ADD expr:rightexpr
541 debugMessage(PRODSTRING);
542 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
543 bool.addChild("op").addChild("add");
544 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
545 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
546 RESULT = bool.getRoot();
549 | expr:leftexpr SUB expr:rightexpr
551 debugMessage(PRODSTRING);
552 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
553 bool.addChild("op").addChild("sub");
554 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
555 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
556 RESULT = bool.getRoot();
559 | expr:leftexpr DIV expr:rightexpr
561 debugMessage(PRODSTRING);
562 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
563 bool.addChild("op").addChild("div");
564 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
565 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
566 RESULT = bool.getRoot();
569 | expr:leftexpr MULT expr:rightexpr
571 debugMessage(PRODSTRING);
572 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
573 bool.addChild("op").addChild("mult");
574 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
575 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
576 RESULT = bool.getRoot();
579 | expr:leftexpr AND expr:rightexpr
581 debugMessage(PRODSTRING);
582 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
583 bool.addChild("op").addChild("and");
584 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
585 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
586 RESULT = bool.getRoot();
589 | expr:leftexpr OR expr:rightexpr
591 debugMessage(PRODSTRING);
592 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
593 bool.addChild("op").addChild("and");
594 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
595 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
596 RESULT = bool.getRoot();
601 debugMessage(PRODSTRING);
602 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
603 bool.addChild("op").addChild("not");
604 bool.addChild("left").addChild(expr);
605 RESULT = bool.getRoot();
608 | ISVALID OPENPAREN expr:innerexpr CLOSEPAREN
610 debugMessage(PRODSTRING);
611 ParseNode expr = new ParseNode("expr", parser.curLine(4));
612 expr.addChild("isvalid").addChild(innerexpr);
616 | ISVALID OPENPAREN expr:innerexpr COMMA ID:type CLOSEPAREN
618 debugMessage(PRODSTRING);
619 ParseNode isvalid = (new ParseNode("expr", parser.curLine(6))).addChild("isvalid");
620 isvalid.addChild(innerexpr);
621 isvalid.addChild("type", parser.curLine(2)).addChild(type);
622 RESULT = isvalid.getRoot();
626 /** standard *********************************/
632 debugMessage(PRODSTRING);
633 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
638 debugMessage(PRODSTRING);
639 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
644 debugMessage(PRODSTRING);
645 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
650 debugMessage(PRODSTRING);
651 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
656 debugMessage(PRODSTRING);
657 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
662 debugMessage(PRODSTRING);
663 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();
671 debugMessage(PRODSTRING);
672 ParseNode set = new ParseNode("set", parser.curLine(1));
673 set.addChild("name").addChild(setname);
677 | OPENBRACE listofliterals:list CLOSEBRACE
679 debugMessage(PRODSTRING);
680 ParseNode set = new ParseNode("set", parser.curLine(3));
689 listofliterals:list COMMA literal:literal
691 debugMessage(PRODSTRING);
692 list.addChild(literal);
698 debugMessage(PRODSTRING);
699 ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
700 list.addChild(literal);