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 void syntax_error (java_cup.runtime.Symbol current) {
62 CUP$MDLParser$actions.errors = true;
63 Symbol symbol = (Symbol) current;
64 report_error("MDL: Syntax error at line " + (symbol.line + 1)
65 + ", column " + LineCount.getColumn(symbol.left) + ": " + current.value, current);
68 public void report_fatal_error (String message, Object info) {
71 report_error(message, info);
72 CUP$MDLParser$actions.errors = true;
75 public int curPos () {
76 return cur_token.left;
79 public int curLine (int back) {
80 Stack st = new Stack();
83 for (i = 0; i < back; i++) {
87 java_cup.runtime.Symbol s;
88 s = (java_cup.runtime.Symbol) st.peek();
90 for (i = 0; i < back; i++) {
94 return LineCount.getLine(s.left);
99 // TERMINALS /////////////////////////////////////////////////////////////
104 terminal String DECIMAL;
105 terminal String CHAR;
106 terminal String STRING;
112 terminal OPENBRACKET;
113 terminal CLOSEBRACKET;
179 // NON-TERMINALS /////////////////////////////////////////////////////////
183 ------------------------------------------------------------------------*/
185 nonterminal ParseNode rules;
186 nonterminal ParseNode rule;
187 nonterminal ParseNode ruletype;
188 nonterminal ParseNode optquantifiers;
189 nonterminal ParseNode quantifiers;
190 nonterminal ParseNode quantifier;
191 nonterminal ParseNode inclusion;
192 nonterminal ParseNode expr;
193 nonterminal ParseNode literal;
195 nonterminal ParseNode simple_expr;
196 nonterminal ParseNode location;
198 nonterminal ParseNode set;
199 nonterminal ParseNode listofliterals;
201 precedence nonassoc OR;
202 precedence nonassoc AND;
204 precedence nonassoc EQ, NE;
205 precedence nonassoc LT, LE, GE, GT;
207 precedence left INTEST;
209 precedence left ADD, SUB;
210 precedence left MULT, DIV;
214 // PRODUCTION RULES /////////////////////////////////////////////////////
220 rules:rules rule:rule
222 debugMessage(PRODSTRING);
223 rules.addChild(rule);
229 debugMessage(PRODSTRING);
230 ParseNode rules = new ParseNode("rules", parser.curLine(1));
231 rules.addChild(rule);
238 ruletype:ruletype OPENBRACKET optquantifiers:quantifiers CLOSEBRACKET
239 COMMA expr:guard IMPLIES inclusion:inclusion SEMICOLON
241 debugMessage(PRODSTRING);
242 ParseNode rule = new ParseNode("rule", parser.curLine(9));
243 if (ruletype != null) {
244 rule.addChild(ruletype);
246 if (quantifiers != null) {
247 rule.addChild(quantifiers);
249 rule.addChild(guard);
250 rule.addChild(inclusion);
259 debugMessage(PRODSTRING);
260 RESULT = new ParseNode("static", parser.curLine(1));
265 debugMessage(PRODSTRING);
266 RESULT = new ParseNode("delay", parser.curLine(1));
271 debugMessage(PRODSTRING);
278 quantifiers:quantifiers
280 debugMessage(PRODSTRING);
281 RESULT = quantifiers;
286 debugMessage(PRODSTRING);
293 quantifiers:quantifiers COMMA quantifier:quantifier
295 debugMessage(PRODSTRING);
296 quantifiers.addChild(quantifier);
297 RESULT = quantifiers;
300 | quantifier:quantifier
302 debugMessage(PRODSTRING);
303 ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
304 quantifiers.addChild(quantifier);
305 RESULT = quantifiers;
311 FORALL ID:var IN set:set
313 debugMessage(PRODSTRING);
314 ParseNode q = new ParseNode("quantifier", parser.curLine(4));
315 q.addChild("forall", parser.curLine(4));
316 q.addChild("var", parser.curLine(3)).addChild(var);
321 | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
323 debugMessage(PRODSTRING);
324 ParseNode q = new ParseNode("quantifier", parser.curLine(7));
325 q.addChild("relation", parser.curLine(1)).addChild(relation);
326 q.addChild("left", parser.curLine(5)).addChild(r1);
327 q.addChild("right", parser.curLine(3)).addChild(r2);
331 | FOR ID:var EQ expr:lower TO expr:upper
333 debugMessage(PRODSTRING);
334 ParseNode q = new ParseNode("quantifier", parser.curLine(5));
336 q.addChild("var", parser.curLine(4)).addChild(var);
337 q.addChild("lower", parser.curLine(3)).addChild(lower);
338 q.addChild("upper", parser.curLine(1)).addChild(upper);
345 expr:expr IN ID:setname
347 debugMessage(PRODSTRING);
348 ParseNode set = (new ParseNode("inclusion", parser.curLine(3))).addChild("set");
350 set.addChild("name", parser.curLine(1)).addChild(setname);
351 RESULT = set.getRoot();
354 | LT expr:r1 COMMA expr:r2 GT IN ID:relationname
356 debugMessage(PRODSTRING);
357 ParseNode relation = (new ParseNode("inclusion", parser.curLine(7))).addChild("relation");
358 relation.addChild("left").addChild(r1);
359 relation.addChild("right").addChild(r2);
360 relation.addChild("name", parser.curLine(1)).addChild(relationname);
361 RESULT = relation.getRoot();
369 debugMessage(PRODSTRING);
370 ParseNode se = new ParseNode("simple_expr", parser.curLine(1));
371 se.addChild(location);
380 debugMessage(PRODSTRING);
381 ParseNode loc = new ParseNode("location", parser.curLine(1));
382 loc.addChild("var").addChild(var);
386 | simple_expr:dotexpr DOT ID:field
388 debugMessage(PRODSTRING);
389 ParseNode dot = (new ParseNode("location", parser.curLine(3))).addChild("dot");
390 dot.addChild(dotexpr);
391 dot.addChild("field", parser.curLine(1)).addChild(field);
392 RESULT = dot.getRoot();
395 | simple_expr:dotexpr DOT ID:field OPENBRACKET expr:index CLOSEBRACKET
397 debugMessage(PRODSTRING);
398 ParseNode dot = (new ParseNode("location", parser.curLine(6))).addChild("dot");
399 dot.addChild(dotexpr);
400 dot.addChild("field", parser.curLine(4)).addChild(field);
401 dot.addChild("index", parser.curLine(2)).addChild(index);
402 RESULT = dot.getRoot();
405 | CAST OPENPAREN ID:type COMMA simple_expr:expr CLOSEPAREN
407 debugMessage(PRODSTRING);
408 ParseNode cast = (new ParseNode("location", parser.curLine(6))).addChild("cast");
409 cast.addChild("type").addChild(type);
411 RESULT = cast.getRoot();
419 debugMessage(PRODSTRING);
420 ParseNode expr = new ParseNode("expr", parser.curLine(1));
425 | expr:expr INTEST ID:setname
427 debugMessage(PRODSTRING);
428 ParseNode elementof = (new ParseNode("expr", parser.curLine(3))).addChild("elementof");
429 elementof.addChild(expr);
430 elementof.addChild("name").addChild(setname);
431 RESULT = elementof.getRoot();
434 | LT expr:r1 COMMA expr:r2 GT INTEST ID:relationname
436 debugMessage(PRODSTRING);
437 ParseNode tupleof = (new ParseNode("expr", parser.curLine(7))).addChild("tupleof");
438 tupleof.addChild("left").addChild(r1);
439 tupleof.addChild("right").addChild(r2);
440 tupleof.addChild("name").addChild(relationname);
441 RESULT = tupleof.getRoot();
444 | OPENPAREN expr:expr CLOSEPAREN
446 debugMessage(PRODSTRING);
450 | LITERAL OPENPAREN literal:literal CLOSEPAREN
452 debugMessage(PRODSTRING);
453 ParseNode expr = new ParseNode("expr", parser.curLine(4));
454 expr.addChild(literal);
458 | expr:leftexpr LT expr:rightexpr
460 debugMessage(PRODSTRING);
461 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
462 bool.addChild("op").addChild("lt");
463 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
464 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
465 RESULT = bool.getRoot();
468 | expr:leftexpr LE expr:rightexpr
470 debugMessage(PRODSTRING);
471 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
472 bool.addChild("op").addChild("le");
473 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
474 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
475 RESULT = bool.getRoot();
478 | expr:leftexpr GT expr:rightexpr
480 debugMessage(PRODSTRING);
481 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
482 bool.addChild("op").addChild("gt");
483 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
484 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
485 RESULT = bool.getRoot();
488 | expr:leftexpr GE expr:rightexpr
490 debugMessage(PRODSTRING);
491 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
492 bool.addChild("op").addChild("ge");
493 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
494 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
495 RESULT = bool.getRoot();
498 | expr:leftexpr EQ expr:rightexpr
500 debugMessage(PRODSTRING);
501 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
502 bool.addChild("op").addChild("eq");
503 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
504 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
505 RESULT = bool.getRoot();
508 | expr:leftexpr NE expr:rightexpr
510 debugMessage(PRODSTRING);
511 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
512 bool.addChild("op").addChild("ne");
513 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
514 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
515 RESULT = bool.getRoot();
518 | expr:leftexpr ADD expr:rightexpr
520 debugMessage(PRODSTRING);
521 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
522 bool.addChild("op").addChild("add");
523 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
524 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
525 RESULT = bool.getRoot();
528 | expr:leftexpr SUB expr:rightexpr
530 debugMessage(PRODSTRING);
531 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
532 bool.addChild("op").addChild("sub");
533 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
534 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
535 RESULT = bool.getRoot();
538 | expr:leftexpr DIV expr:rightexpr
540 debugMessage(PRODSTRING);
541 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
542 bool.addChild("op").addChild("div");
543 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
544 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
545 RESULT = bool.getRoot();
548 | expr:leftexpr MULT expr:rightexpr
550 debugMessage(PRODSTRING);
551 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
552 bool.addChild("op").addChild("mult");
553 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
554 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
555 RESULT = bool.getRoot();
558 | expr:leftexpr AND expr:rightexpr
560 debugMessage(PRODSTRING);
561 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
562 bool.addChild("op").addChild("and");
563 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
564 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
565 RESULT = bool.getRoot();
568 | expr:leftexpr OR expr:rightexpr
570 debugMessage(PRODSTRING);
571 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
572 bool.addChild("op").addChild("and");
573 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
574 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
575 RESULT = bool.getRoot();
580 debugMessage(PRODSTRING);
581 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
582 bool.addChild("op").addChild("not");
583 bool.addChild("left").addChild(expr);
584 RESULT = bool.getRoot();
587 | ISVALID OPENPAREN expr:innerexpr CLOSEPAREN
589 debugMessage(PRODSTRING);
590 ParseNode expr = new ParseNode("expr", parser.curLine(4));
591 expr.addChild("isvalid").addChild(innerexpr);
595 | ISVALID OPENPAREN expr:innerexpr COMMA ID:type CLOSEPAREN
597 debugMessage(PRODSTRING);
598 ParseNode isvalid = (new ParseNode("expr", parser.curLine(6))).addChild("isvalid");
599 isvalid.addChild(innerexpr);
600 isvalid.addChild("type", parser.curLine(2)).addChild(type);
601 RESULT = isvalid.getRoot();
605 /** standard *********************************/
611 debugMessage(PRODSTRING);
612 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
617 debugMessage(PRODSTRING);
618 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
623 debugMessage(PRODSTRING);
624 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
629 debugMessage(PRODSTRING);
630 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
635 debugMessage(PRODSTRING);
636 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
641 debugMessage(PRODSTRING);
642 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();
650 debugMessage(PRODSTRING);
651 ParseNode set = new ParseNode("set", parser.curLine(1));
652 set.addChild("name").addChild(setname);
656 | OPENBRACE listofliterals:list CLOSEBRACE
658 debugMessage(PRODSTRING);
659 ParseNode set = new ParseNode("set", parser.curLine(3));
668 listofliterals:list COMMA literal:literal
670 debugMessage(PRODSTRING);
671 list.addChild(literal);
677 debugMessage(PRODSTRING);
678 ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
679 list.addChild(literal);