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;
205 // NON-TERMINALS /////////////////////////////////////////////////////////
209 ------------------------------------------------------------------------*/
211 nonterminal ParseNode rules;
212 nonterminal ParseNode rule;
213 nonterminal ParseNode ruletype;
214 nonterminal ParseNode optquantifiers;
215 nonterminal ParseNode quantifiers;
216 nonterminal ParseNode quantifier;
217 nonterminal ParseNode inclusion;
218 nonterminal ParseNode expr;
219 nonterminal ParseNode literal;
221 nonterminal ParseNode simple_expr;
222 nonterminal ParseNode location;
224 nonterminal ParseNode set;
225 nonterminal ParseNode listofliterals;
227 precedence nonassoc OR;
228 precedence nonassoc AND;
230 precedence nonassoc EQ, NE;
231 precedence nonassoc LT, LE, GE, GT;
233 precedence left INTEST;
235 precedence left ADD, SUB;
236 precedence left MULT, DIV;
240 // PRODUCTION RULES /////////////////////////////////////////////////////
246 rules:rules rule:rule
248 debugMessage(PRODSTRING);
249 rules.addChild(rule);
255 debugMessage(PRODSTRING);
256 ParseNode rules = new ParseNode("rules", parser.curLine(1));
257 rules.addChild(rule);
264 ruletype:ruletype OPENBRACKET optquantifiers:quantifiers CLOSEBRACKET
265 COMMA expr:guard IMPLIES inclusion:inclusion SEMICOLON
267 debugMessage(PRODSTRING);
268 ParseNode rule = new ParseNode("rule", parser.curLine(9));
269 if (ruletype != null) {
270 rule.addChild(ruletype);
272 if (quantifiers != null) {
273 rule.addChild(quantifiers);
275 rule.addChild(guard);
276 rule.addChild(inclusion);
285 debugMessage(PRODSTRING);
286 RESULT = new ParseNode("static", parser.curLine(1));
291 debugMessage(PRODSTRING);
292 RESULT = new ParseNode("delay", parser.curLine(1));
297 debugMessage(PRODSTRING);
304 quantifiers:quantifiers
306 debugMessage(PRODSTRING);
307 RESULT = quantifiers;
312 debugMessage(PRODSTRING);
319 quantifiers:quantifiers COMMA quantifier:quantifier
321 debugMessage(PRODSTRING);
322 quantifiers.addChild(quantifier);
323 RESULT = quantifiers;
326 | quantifier:quantifier
328 debugMessage(PRODSTRING);
329 ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
330 quantifiers.addChild(quantifier);
331 RESULT = quantifiers;
337 FORALL ID:var IN set:set
339 debugMessage(PRODSTRING);
340 ParseNode q = new ParseNode("quantifier", parser.curLine(4));
341 q.addChild("forall", parser.curLine(4));
342 q.addChild("var", parser.curLine(3)).addChild(var);
347 | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
349 debugMessage(PRODSTRING);
350 ParseNode q = new ParseNode("quantifier", parser.curLine(7));
351 q.addChild("relation", parser.curLine(1)).addChild(relation);
352 q.addChild("left", parser.curLine(5)).addChild(r1);
353 q.addChild("right", parser.curLine(3)).addChild(r2);
357 | FOR ID:var EQ expr:lower TO expr:upper
359 debugMessage(PRODSTRING);
360 ParseNode q = new ParseNode("quantifier", parser.curLine(5));
362 q.addChild("var", parser.curLine(4)).addChild(var);
363 q.addChild("lower", parser.curLine(3)).addChild(lower);
364 q.addChild("upper", parser.curLine(1)).addChild(upper);
371 expr:expr IN ID:setname
373 debugMessage(PRODSTRING);
374 ParseNode set = (new ParseNode("inclusion", parser.curLine(3))).addChild("set");
376 set.addChild("name", parser.curLine(1)).addChild(setname);
377 RESULT = set.getRoot();
380 | LT expr:r1 COMMA expr:r2 GT IN ID:relationname
382 debugMessage(PRODSTRING);
383 ParseNode relation = (new ParseNode("inclusion", parser.curLine(7))).addChild("relation");
384 relation.addChild("left").addChild(r1);
385 relation.addChild("right").addChild(r2);
386 relation.addChild("name", parser.curLine(1)).addChild(relationname);
387 RESULT = relation.getRoot();
395 debugMessage(PRODSTRING);
396 ParseNode se = new ParseNode("simple_expr", parser.curLine(1));
397 se.addChild(location);
406 debugMessage(PRODSTRING);
407 ParseNode loc = new ParseNode("location", parser.curLine(1));
408 loc.addChild("var").addChild(var);
412 | simple_expr:dotexpr DOT ID:field
414 debugMessage(PRODSTRING);
415 ParseNode dot = (new ParseNode("location", parser.curLine(3))).addChild("dot");
416 dot.addChild(dotexpr);
417 dot.addChild("field", parser.curLine(1)).addChild(field);
418 RESULT = dot.getRoot();
421 | simple_expr:dotexpr DOT ID:field OPENBRACKET expr:index CLOSEBRACKET
423 debugMessage(PRODSTRING);
424 ParseNode dot = (new ParseNode("location", parser.curLine(6))).addChild("dot");
425 dot.addChild(dotexpr);
426 dot.addChild("field", parser.curLine(4)).addChild(field);
427 dot.addChild("index", parser.curLine(2)).addChild(index);
428 RESULT = dot.getRoot();
431 | CAST OPENPAREN ID:type COMMA simple_expr:expr CLOSEPAREN
433 debugMessage(PRODSTRING);
434 ParseNode cast = (new ParseNode("location", parser.curLine(6))).addChild("cast");
435 cast.addChild("type").addChild(type);
437 RESULT = cast.getRoot();
445 debugMessage(PRODSTRING);
446 ParseNode expr = new ParseNode("expr", parser.curLine(1));
451 | expr:expr INTEST ID:setname
453 debugMessage(PRODSTRING);
454 ParseNode elementof = (new ParseNode("expr", parser.curLine(3))).addChild("elementof");
455 elementof.addChild(expr);
456 elementof.addChild("name").addChild(setname);
457 RESULT = elementof.getRoot();
460 | LT expr:r1 COMMA expr:r2 GT INTEST ID:relationname
462 debugMessage(PRODSTRING);
463 ParseNode tupleof = (new ParseNode("expr", parser.curLine(7))).addChild("tupleof");
464 tupleof.addChild("left").addChild(r1);
465 tupleof.addChild("right").addChild(r2);
466 tupleof.addChild("name").addChild(relationname);
467 RESULT = tupleof.getRoot();
470 | OPENPAREN expr:expr CLOSEPAREN
472 debugMessage(PRODSTRING);
478 debugMessage(PRODSTRING);
479 ParseNode expr = new ParseNode("expr", parser.curLine(4));
480 expr.addChild(literal);
485 | expr:leftexpr LT expr:rightexpr
487 debugMessage(PRODSTRING);
488 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
489 bool.addChild("op").addChild("lt");
490 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
491 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
492 RESULT = bool.getRoot();
495 | expr:leftexpr LE expr:rightexpr
497 debugMessage(PRODSTRING);
498 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
499 bool.addChild("op").addChild("le");
500 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
501 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
502 RESULT = bool.getRoot();
505 | expr:leftexpr GT expr:rightexpr
507 debugMessage(PRODSTRING);
508 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
509 bool.addChild("op").addChild("gt");
510 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
511 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
512 RESULT = bool.getRoot();
515 | expr:leftexpr GE expr:rightexpr
517 debugMessage(PRODSTRING);
518 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
519 bool.addChild("op").addChild("ge");
520 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
521 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
522 RESULT = bool.getRoot();
525 | expr:leftexpr EQ expr:rightexpr
527 debugMessage(PRODSTRING);
528 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
529 bool.addChild("op").addChild("eq");
530 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
531 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
532 RESULT = bool.getRoot();
535 | expr:leftexpr NE expr:rightexpr
537 debugMessage(PRODSTRING);
538 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
539 bool.addChild("op").addChild("ne");
540 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
541 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
542 RESULT = bool.getRoot();
545 | expr:leftexpr ADD expr:rightexpr
547 debugMessage(PRODSTRING);
548 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
549 bool.addChild("op").addChild("add");
550 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
551 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
552 RESULT = bool.getRoot();
555 | expr:leftexpr SUB expr:rightexpr
557 debugMessage(PRODSTRING);
558 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
559 bool.addChild("op").addChild("sub");
560 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
561 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
562 RESULT = bool.getRoot();
565 | expr:leftexpr DIV expr:rightexpr
567 debugMessage(PRODSTRING);
568 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
569 bool.addChild("op").addChild("div");
570 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
571 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
572 RESULT = bool.getRoot();
575 | expr:leftexpr MULT expr:rightexpr
577 debugMessage(PRODSTRING);
578 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
579 bool.addChild("op").addChild("mult");
580 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
581 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
582 RESULT = bool.getRoot();
585 | expr:leftexpr AND expr:rightexpr
587 debugMessage(PRODSTRING);
588 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
589 bool.addChild("op").addChild("and");
590 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
591 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
592 RESULT = bool.getRoot();
595 | expr:leftexpr OR expr:rightexpr
597 debugMessage(PRODSTRING);
598 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
599 bool.addChild("op").addChild("or");
600 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
601 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
602 RESULT = bool.getRoot();
607 debugMessage(PRODSTRING);
608 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
609 bool.addChild("op").addChild("not");
610 bool.addChild("left").addChild(expr);
611 RESULT = bool.getRoot();
614 | ISVALID OPENPAREN expr:innerexpr CLOSEPAREN
616 debugMessage(PRODSTRING);
617 ParseNode expr = new ParseNode("expr", parser.curLine(4));
618 expr.addChild("isvalid").addChild(innerexpr);
622 | ISVALID OPENPAREN expr:innerexpr COMMA ID:type CLOSEPAREN
624 debugMessage(PRODSTRING);
625 ParseNode isvalid = (new ParseNode("expr", parser.curLine(6))).addChild("isvalid");
626 isvalid.addChild(innerexpr);
627 isvalid.addChild("type", parser.curLine(2)).addChild(type);
628 RESULT = isvalid.getRoot();
632 /** standard *********************************/
638 debugMessage(PRODSTRING);
639 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
644 debugMessage(PRODSTRING);
645 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
650 debugMessage(PRODSTRING);
651 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild("0").getRoot();
656 debugMessage(PRODSTRING);
657 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
662 debugMessage(PRODSTRING);
663 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild("-"+dec).getRoot();
668 debugMessage(PRODSTRING);
669 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
674 debugMessage(PRODSTRING);
675 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
678 | LITERAL OPENPAREN ID:literal CLOSEPAREN
680 debugMessage(PRODSTRING);
681 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();
689 debugMessage(PRODSTRING);
690 ParseNode set = new ParseNode("set", parser.curLine(1));
691 set.addChild("name").addChild(setname);
695 | OPENBRACE listofliterals:list CLOSEBRACE
697 debugMessage(PRODSTRING);
698 ParseNode set = new ParseNode("set", parser.curLine(3));
707 listofliterals:list COMMA literal:literal
709 debugMessage(PRODSTRING);
710 list.addChild(literal);
716 debugMessage(PRODSTRING);
717 ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
718 list.addChild(literal);