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;
66 report_error(filename+": Syntax error at line " +
67 (symbol.line + 1) + ", column " + LineCount.getColumn(symbol.left) +
68 ": " + current.value, current);
71 public void report_fatal_error (String message, Object info) {
74 report_error(message, info);
75 CUP$MDLParser$actions.errors = true;
78 public int curPos () {
79 return cur_token.left;
82 public int curLine (int back) {
83 Stack st = new Stack();
86 for (i = 0; i < back; i++) {
90 java_cup.runtime.Symbol s;
91 s = (java_cup.runtime.Symbol) st.peek();
93 for (i = 0; i < back; i++) {
97 return LineCount.getLine(s.left);
102 // TERMINALS /////////////////////////////////////////////////////////////
107 terminal String DECIMAL;
108 terminal String CHAR;
109 terminal String STRING;
115 terminal OPENBRACKET;
116 terminal CLOSEBRACKET;
182 // NON-TERMINALS /////////////////////////////////////////////////////////
186 ------------------------------------------------------------------------*/
188 nonterminal ParseNode rules;
189 nonterminal ParseNode rule;
190 nonterminal ParseNode ruletype;
191 nonterminal ParseNode optquantifiers;
192 nonterminal ParseNode quantifiers;
193 nonterminal ParseNode quantifier;
194 nonterminal ParseNode inclusion;
195 nonterminal ParseNode expr;
196 nonterminal ParseNode literal;
198 nonterminal ParseNode simple_expr;
199 nonterminal ParseNode location;
201 nonterminal ParseNode set;
202 nonterminal ParseNode listofliterals;
204 precedence nonassoc OR;
205 precedence nonassoc AND;
207 precedence nonassoc EQ, NE;
208 precedence nonassoc LT, LE, GE, GT;
210 precedence left INTEST;
212 precedence left ADD, SUB;
213 precedence left MULT, DIV;
217 // PRODUCTION RULES /////////////////////////////////////////////////////
223 rules:rules rule:rule
225 debugMessage(PRODSTRING);
226 rules.addChild(rule);
232 debugMessage(PRODSTRING);
233 ParseNode rules = new ParseNode("rules", parser.curLine(1));
234 rules.addChild(rule);
241 ruletype:ruletype OPENBRACKET optquantifiers:quantifiers CLOSEBRACKET
242 COMMA expr:guard IMPLIES inclusion:inclusion SEMICOLON
244 debugMessage(PRODSTRING);
245 ParseNode rule = new ParseNode("rule", parser.curLine(9));
246 if (ruletype != null) {
247 rule.addChild(ruletype);
249 if (quantifiers != null) {
250 rule.addChild(quantifiers);
252 rule.addChild(guard);
253 rule.addChild(inclusion);
262 debugMessage(PRODSTRING);
263 RESULT = new ParseNode("static", parser.curLine(1));
268 debugMessage(PRODSTRING);
269 RESULT = new ParseNode("delay", parser.curLine(1));
274 debugMessage(PRODSTRING);
281 quantifiers:quantifiers
283 debugMessage(PRODSTRING);
284 RESULT = quantifiers;
289 debugMessage(PRODSTRING);
296 quantifiers:quantifiers COMMA quantifier:quantifier
298 debugMessage(PRODSTRING);
299 quantifiers.addChild(quantifier);
300 RESULT = quantifiers;
303 | quantifier:quantifier
305 debugMessage(PRODSTRING);
306 ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
307 quantifiers.addChild(quantifier);
308 RESULT = quantifiers;
314 FORALL ID:var IN set:set
316 debugMessage(PRODSTRING);
317 ParseNode q = new ParseNode("quantifier", parser.curLine(4));
318 q.addChild("forall", parser.curLine(4));
319 q.addChild("var", parser.curLine(3)).addChild(var);
324 | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
326 debugMessage(PRODSTRING);
327 ParseNode q = new ParseNode("quantifier", parser.curLine(7));
328 q.addChild("relation", parser.curLine(1)).addChild(relation);
329 q.addChild("left", parser.curLine(5)).addChild(r1);
330 q.addChild("right", parser.curLine(3)).addChild(r2);
334 | FOR ID:var EQ expr:lower TO expr:upper
336 debugMessage(PRODSTRING);
337 ParseNode q = new ParseNode("quantifier", parser.curLine(5));
339 q.addChild("var", parser.curLine(4)).addChild(var);
340 q.addChild("lower", parser.curLine(3)).addChild(lower);
341 q.addChild("upper", parser.curLine(1)).addChild(upper);
348 expr:expr IN ID:setname
350 debugMessage(PRODSTRING);
351 ParseNode set = (new ParseNode("inclusion", parser.curLine(3))).addChild("set");
353 set.addChild("name", parser.curLine(1)).addChild(setname);
354 RESULT = set.getRoot();
357 | LT expr:r1 COMMA expr:r2 GT IN ID:relationname
359 debugMessage(PRODSTRING);
360 ParseNode relation = (new ParseNode("inclusion", parser.curLine(7))).addChild("relation");
361 relation.addChild("left").addChild(r1);
362 relation.addChild("right").addChild(r2);
363 relation.addChild("name", parser.curLine(1)).addChild(relationname);
364 RESULT = relation.getRoot();
372 debugMessage(PRODSTRING);
373 ParseNode se = new ParseNode("simple_expr", parser.curLine(1));
374 se.addChild(location);
383 debugMessage(PRODSTRING);
384 ParseNode loc = new ParseNode("location", parser.curLine(1));
385 loc.addChild("var").addChild(var);
389 | simple_expr:dotexpr DOT ID:field
391 debugMessage(PRODSTRING);
392 ParseNode dot = (new ParseNode("location", parser.curLine(3))).addChild("dot");
393 dot.addChild(dotexpr);
394 dot.addChild("field", parser.curLine(1)).addChild(field);
395 RESULT = dot.getRoot();
398 | simple_expr:dotexpr DOT ID:field OPENBRACKET expr:index CLOSEBRACKET
400 debugMessage(PRODSTRING);
401 ParseNode dot = (new ParseNode("location", parser.curLine(6))).addChild("dot");
402 dot.addChild(dotexpr);
403 dot.addChild("field", parser.curLine(4)).addChild(field);
404 dot.addChild("index", parser.curLine(2)).addChild(index);
405 RESULT = dot.getRoot();
408 | CAST OPENPAREN ID:type COMMA simple_expr:expr CLOSEPAREN
410 debugMessage(PRODSTRING);
411 ParseNode cast = (new ParseNode("location", parser.curLine(6))).addChild("cast");
412 cast.addChild("type").addChild(type);
414 RESULT = cast.getRoot();
422 debugMessage(PRODSTRING);
423 ParseNode expr = new ParseNode("expr", parser.curLine(1));
428 | expr:expr INTEST ID:setname
430 debugMessage(PRODSTRING);
431 ParseNode elementof = (new ParseNode("expr", parser.curLine(3))).addChild("elementof");
432 elementof.addChild(expr);
433 elementof.addChild("name").addChild(setname);
434 RESULT = elementof.getRoot();
437 | LT expr:r1 COMMA expr:r2 GT INTEST ID:relationname
439 debugMessage(PRODSTRING);
440 ParseNode tupleof = (new ParseNode("expr", parser.curLine(7))).addChild("tupleof");
441 tupleof.addChild("left").addChild(r1);
442 tupleof.addChild("right").addChild(r2);
443 tupleof.addChild("name").addChild(relationname);
444 RESULT = tupleof.getRoot();
447 | OPENPAREN expr:expr CLOSEPAREN
449 debugMessage(PRODSTRING);
453 | LITERAL OPENPAREN literal:literal CLOSEPAREN
455 debugMessage(PRODSTRING);
456 ParseNode expr = new ParseNode("expr", parser.curLine(4));
457 expr.addChild(literal);
461 | expr:leftexpr LT expr:rightexpr
463 debugMessage(PRODSTRING);
464 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
465 bool.addChild("op").addChild("lt");
466 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
467 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
468 RESULT = bool.getRoot();
471 | expr:leftexpr LE expr:rightexpr
473 debugMessage(PRODSTRING);
474 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
475 bool.addChild("op").addChild("le");
476 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
477 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
478 RESULT = bool.getRoot();
481 | expr:leftexpr GT expr:rightexpr
483 debugMessage(PRODSTRING);
484 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
485 bool.addChild("op").addChild("gt");
486 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
487 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
488 RESULT = bool.getRoot();
491 | expr:leftexpr GE expr:rightexpr
493 debugMessage(PRODSTRING);
494 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
495 bool.addChild("op").addChild("ge");
496 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
497 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
498 RESULT = bool.getRoot();
501 | expr:leftexpr EQ expr:rightexpr
503 debugMessage(PRODSTRING);
504 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
505 bool.addChild("op").addChild("eq");
506 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
507 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
508 RESULT = bool.getRoot();
511 | expr:leftexpr NE expr:rightexpr
513 debugMessage(PRODSTRING);
514 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
515 bool.addChild("op").addChild("ne");
516 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
517 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
518 RESULT = bool.getRoot();
521 | expr:leftexpr ADD expr:rightexpr
523 debugMessage(PRODSTRING);
524 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
525 bool.addChild("op").addChild("add");
526 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
527 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
528 RESULT = bool.getRoot();
531 | expr:leftexpr SUB expr:rightexpr
533 debugMessage(PRODSTRING);
534 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
535 bool.addChild("op").addChild("sub");
536 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
537 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
538 RESULT = bool.getRoot();
541 | expr:leftexpr DIV expr:rightexpr
543 debugMessage(PRODSTRING);
544 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
545 bool.addChild("op").addChild("div");
546 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
547 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
548 RESULT = bool.getRoot();
551 | expr:leftexpr MULT expr:rightexpr
553 debugMessage(PRODSTRING);
554 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
555 bool.addChild("op").addChild("mult");
556 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
557 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
558 RESULT = bool.getRoot();
561 | expr:leftexpr AND expr:rightexpr
563 debugMessage(PRODSTRING);
564 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
565 bool.addChild("op").addChild("and");
566 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
567 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
568 RESULT = bool.getRoot();
571 | expr:leftexpr OR expr:rightexpr
573 debugMessage(PRODSTRING);
574 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
575 bool.addChild("op").addChild("and");
576 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
577 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
578 RESULT = bool.getRoot();
583 debugMessage(PRODSTRING);
584 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
585 bool.addChild("op").addChild("not");
586 bool.addChild("left").addChild(expr);
587 RESULT = bool.getRoot();
590 | ISVALID OPENPAREN expr:innerexpr CLOSEPAREN
592 debugMessage(PRODSTRING);
593 ParseNode expr = new ParseNode("expr", parser.curLine(4));
594 expr.addChild("isvalid").addChild(innerexpr);
598 | ISVALID OPENPAREN expr:innerexpr COMMA ID:type CLOSEPAREN
600 debugMessage(PRODSTRING);
601 ParseNode isvalid = (new ParseNode("expr", parser.curLine(6))).addChild("isvalid");
602 isvalid.addChild(innerexpr);
603 isvalid.addChild("type", parser.curLine(2)).addChild(type);
604 RESULT = isvalid.getRoot();
608 /** standard *********************************/
614 debugMessage(PRODSTRING);
615 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
620 debugMessage(PRODSTRING);
621 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
626 debugMessage(PRODSTRING);
627 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
632 debugMessage(PRODSTRING);
633 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
638 debugMessage(PRODSTRING);
639 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
644 debugMessage(PRODSTRING);
645 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();
653 debugMessage(PRODSTRING);
654 ParseNode set = new ParseNode("set", parser.curLine(1));
655 set.addChild("name").addChild(setname);
659 | OPENBRACE listofliterals:list CLOSEBRACE
661 debugMessage(PRODSTRING);
662 ParseNode set = new ParseNode("set", parser.curLine(3));
671 listofliterals:list COMMA literal:literal
673 debugMessage(PRODSTRING);
674 list.addChild(literal);
680 debugMessage(PRODSTRING);
681 ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
682 list.addChild(literal);