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;
202 // NON-TERMINALS /////////////////////////////////////////////////////////
206 ------------------------------------------------------------------------*/
208 nonterminal ParseNode rules;
209 nonterminal ParseNode rule;
210 nonterminal ParseNode ruletype;
211 nonterminal ParseNode optquantifiers;
212 nonterminal ParseNode quantifiers;
213 nonterminal ParseNode quantifier;
214 nonterminal ParseNode inclusion;
215 nonterminal ParseNode expr;
216 nonterminal ParseNode literal;
218 nonterminal ParseNode simple_expr;
219 nonterminal ParseNode location;
221 nonterminal ParseNode set;
222 nonterminal ParseNode listofliterals;
224 precedence nonassoc OR;
225 precedence nonassoc AND;
227 precedence nonassoc EQ, NE;
228 precedence nonassoc LT, LE, GE, GT;
230 precedence left INTEST;
232 precedence left ADD, SUB;
233 precedence left MULT, DIV;
237 // PRODUCTION RULES /////////////////////////////////////////////////////
243 rules:rules rule:rule
245 debugMessage(PRODSTRING);
246 rules.addChild(rule);
252 debugMessage(PRODSTRING);
253 ParseNode rules = new ParseNode("rules", parser.curLine(1));
254 rules.addChild(rule);
261 ruletype:ruletype OPENBRACKET optquantifiers:quantifiers CLOSEBRACKET
262 COMMA expr:guard IMPLIES inclusion:inclusion SEMICOLON
264 debugMessage(PRODSTRING);
265 ParseNode rule = new ParseNode("rule", parser.curLine(9));
266 if (ruletype != null) {
267 rule.addChild(ruletype);
269 if (quantifiers != null) {
270 rule.addChild(quantifiers);
272 rule.addChild(guard);
273 rule.addChild(inclusion);
282 debugMessage(PRODSTRING);
283 RESULT = new ParseNode("static", parser.curLine(1));
288 debugMessage(PRODSTRING);
289 RESULT = new ParseNode("delay", parser.curLine(1));
294 debugMessage(PRODSTRING);
301 quantifiers:quantifiers
303 debugMessage(PRODSTRING);
304 RESULT = quantifiers;
309 debugMessage(PRODSTRING);
316 quantifiers:quantifiers COMMA quantifier:quantifier
318 debugMessage(PRODSTRING);
319 quantifiers.addChild(quantifier);
320 RESULT = quantifiers;
323 | quantifier:quantifier
325 debugMessage(PRODSTRING);
326 ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
327 quantifiers.addChild(quantifier);
328 RESULT = quantifiers;
334 FORALL ID:var IN set:set
336 debugMessage(PRODSTRING);
337 ParseNode q = new ParseNode("quantifier", parser.curLine(4));
338 q.addChild("forall", parser.curLine(4));
339 q.addChild("var", parser.curLine(3)).addChild(var);
344 | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
346 debugMessage(PRODSTRING);
347 ParseNode q = new ParseNode("quantifier", parser.curLine(7));
348 q.addChild("relation", parser.curLine(1)).addChild(relation);
349 q.addChild("left", parser.curLine(5)).addChild(r1);
350 q.addChild("right", parser.curLine(3)).addChild(r2);
354 | FOR ID:var EQ expr:lower TO expr:upper
356 debugMessage(PRODSTRING);
357 ParseNode q = new ParseNode("quantifier", parser.curLine(5));
359 q.addChild("var", parser.curLine(4)).addChild(var);
360 q.addChild("lower", parser.curLine(3)).addChild(lower);
361 q.addChild("upper", parser.curLine(1)).addChild(upper);
368 expr:expr IN ID:setname
370 debugMessage(PRODSTRING);
371 ParseNode set = (new ParseNode("inclusion", parser.curLine(3))).addChild("set");
373 set.addChild("name", parser.curLine(1)).addChild(setname);
374 RESULT = set.getRoot();
377 | LT expr:r1 COMMA expr:r2 GT IN ID:relationname
379 debugMessage(PRODSTRING);
380 ParseNode relation = (new ParseNode("inclusion", parser.curLine(7))).addChild("relation");
381 relation.addChild("left").addChild(r1);
382 relation.addChild("right").addChild(r2);
383 relation.addChild("name", parser.curLine(1)).addChild(relationname);
384 RESULT = relation.getRoot();
392 debugMessage(PRODSTRING);
393 ParseNode se = new ParseNode("simple_expr", parser.curLine(1));
394 se.addChild(location);
403 debugMessage(PRODSTRING);
404 ParseNode loc = new ParseNode("location", parser.curLine(1));
405 loc.addChild("var").addChild(var);
409 | simple_expr:dotexpr DOT ID:field
411 debugMessage(PRODSTRING);
412 ParseNode dot = (new ParseNode("location", parser.curLine(3))).addChild("dot");
413 dot.addChild(dotexpr);
414 dot.addChild("field", parser.curLine(1)).addChild(field);
415 RESULT = dot.getRoot();
418 | simple_expr:dotexpr DOT ID:field OPENBRACKET expr:index CLOSEBRACKET
420 debugMessage(PRODSTRING);
421 ParseNode dot = (new ParseNode("location", parser.curLine(6))).addChild("dot");
422 dot.addChild(dotexpr);
423 dot.addChild("field", parser.curLine(4)).addChild(field);
424 dot.addChild("index", parser.curLine(2)).addChild(index);
425 RESULT = dot.getRoot();
428 | CAST OPENPAREN ID:type COMMA simple_expr:expr CLOSEPAREN
430 debugMessage(PRODSTRING);
431 ParseNode cast = (new ParseNode("location", parser.curLine(6))).addChild("cast");
432 cast.addChild("type").addChild(type);
434 RESULT = cast.getRoot();
442 debugMessage(PRODSTRING);
443 ParseNode expr = new ParseNode("expr", parser.curLine(1));
448 | expr:expr INTEST ID:setname
450 debugMessage(PRODSTRING);
451 ParseNode elementof = (new ParseNode("expr", parser.curLine(3))).addChild("elementof");
452 elementof.addChild(expr);
453 elementof.addChild("name").addChild(setname);
454 RESULT = elementof.getRoot();
457 | LT expr:r1 COMMA expr:r2 GT INTEST ID:relationname
459 debugMessage(PRODSTRING);
460 ParseNode tupleof = (new ParseNode("expr", parser.curLine(7))).addChild("tupleof");
461 tupleof.addChild("left").addChild(r1);
462 tupleof.addChild("right").addChild(r2);
463 tupleof.addChild("name").addChild(relationname);
464 RESULT = tupleof.getRoot();
467 | OPENPAREN expr:expr CLOSEPAREN
469 debugMessage(PRODSTRING);
475 debugMessage(PRODSTRING);
476 ParseNode expr = new ParseNode("expr", parser.curLine(4));
477 expr.addChild(literal);
482 | expr:leftexpr LT expr:rightexpr
484 debugMessage(PRODSTRING);
485 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
486 bool.addChild("op").addChild("lt");
487 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
488 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
489 RESULT = bool.getRoot();
492 | expr:leftexpr LE expr:rightexpr
494 debugMessage(PRODSTRING);
495 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
496 bool.addChild("op").addChild("le");
497 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
498 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
499 RESULT = bool.getRoot();
502 | expr:leftexpr GT expr:rightexpr
504 debugMessage(PRODSTRING);
505 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
506 bool.addChild("op").addChild("gt");
507 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
508 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
509 RESULT = bool.getRoot();
512 | expr:leftexpr GE expr:rightexpr
514 debugMessage(PRODSTRING);
515 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
516 bool.addChild("op").addChild("ge");
517 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
518 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
519 RESULT = bool.getRoot();
522 | expr:leftexpr EQ expr:rightexpr
524 debugMessage(PRODSTRING);
525 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
526 bool.addChild("op").addChild("eq");
527 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
528 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
529 RESULT = bool.getRoot();
532 | expr:leftexpr NE expr:rightexpr
534 debugMessage(PRODSTRING);
535 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
536 bool.addChild("op").addChild("ne");
537 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
538 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
539 RESULT = bool.getRoot();
542 | expr:leftexpr ADD expr:rightexpr
544 debugMessage(PRODSTRING);
545 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
546 bool.addChild("op").addChild("add");
547 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
548 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
549 RESULT = bool.getRoot();
552 | expr:leftexpr SUB expr:rightexpr
554 debugMessage(PRODSTRING);
555 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
556 bool.addChild("op").addChild("sub");
557 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
558 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
559 RESULT = bool.getRoot();
562 | expr:leftexpr DIV expr:rightexpr
564 debugMessage(PRODSTRING);
565 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
566 bool.addChild("op").addChild("div");
567 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
568 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
569 RESULT = bool.getRoot();
572 | expr:leftexpr MULT expr:rightexpr
574 debugMessage(PRODSTRING);
575 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
576 bool.addChild("op").addChild("mult");
577 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
578 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
579 RESULT = bool.getRoot();
582 | expr:leftexpr AND expr:rightexpr
584 debugMessage(PRODSTRING);
585 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
586 bool.addChild("op").addChild("and");
587 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
588 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
589 RESULT = bool.getRoot();
592 | expr:leftexpr OR expr:rightexpr
594 debugMessage(PRODSTRING);
595 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
596 bool.addChild("op").addChild("and");
597 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
598 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
599 RESULT = bool.getRoot();
604 debugMessage(PRODSTRING);
605 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
606 bool.addChild("op").addChild("not");
607 bool.addChild("left").addChild(expr);
608 RESULT = bool.getRoot();
611 | ISVALID OPENPAREN expr:innerexpr CLOSEPAREN
613 debugMessage(PRODSTRING);
614 ParseNode expr = new ParseNode("expr", parser.curLine(4));
615 expr.addChild("isvalid").addChild(innerexpr);
619 | ISVALID OPENPAREN expr:innerexpr COMMA ID:type CLOSEPAREN
621 debugMessage(PRODSTRING);
622 ParseNode isvalid = (new ParseNode("expr", parser.curLine(6))).addChild("isvalid");
623 isvalid.addChild(innerexpr);
624 isvalid.addChild("type", parser.curLine(2)).addChild(type);
625 RESULT = isvalid.getRoot();
629 /** standard *********************************/
635 debugMessage(PRODSTRING);
636 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
641 debugMessage(PRODSTRING);
642 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
647 debugMessage(PRODSTRING);
648 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild("0").getRoot();
653 debugMessage(PRODSTRING);
654 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
659 debugMessage(PRODSTRING);
660 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
665 debugMessage(PRODSTRING);
666 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
669 | LITERAL OPENPAREN ID:literal CLOSEPAREN
671 debugMessage(PRODSTRING);
672 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();
680 debugMessage(PRODSTRING);
681 ParseNode set = new ParseNode("set", parser.curLine(1));
682 set.addChild("name").addChild(setname);
686 | OPENBRACE listofliterals:list CLOSEBRACE
688 debugMessage(PRODSTRING);
689 ParseNode set = new ParseNode("set", parser.curLine(3));
698 listofliterals:list COMMA literal:literal
700 debugMessage(PRODSTRING);
701 list.addChild(literal);
707 debugMessage(PRODSTRING);
708 ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
709 list.addChild(literal);