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+":"+(symbol.line+1)+": Syntax error at column " + LineCount.getColumn(symbol.left) +": " + current.value, current);
70 public void report_fatal_error (String message, Object info) {
73 report_error(message, info);
74 CUP$MDLParser$actions.errors = true;
77 public int curPos () {
78 return cur_token.left;
81 public int curLine (int back) {
82 Stack st = new Stack();
85 for (i = 0; i < back; i++) {
89 java_cup.runtime.Symbol s;
90 s = (java_cup.runtime.Symbol) st.peek();
92 for (i = 0; i < back; i++) {
96 return LineCount.getLine(s.left);
101 // TERMINALS /////////////////////////////////////////////////////////////
106 terminal String DECIMAL;
107 terminal String CHAR;
108 terminal String STRING;
114 terminal OPENBRACKET;
115 terminal CLOSEBRACKET;
181 // NON-TERMINALS /////////////////////////////////////////////////////////
185 ------------------------------------------------------------------------*/
187 nonterminal ParseNode rules;
188 nonterminal ParseNode rule;
189 nonterminal ParseNode ruletype;
190 nonterminal ParseNode optquantifiers;
191 nonterminal ParseNode quantifiers;
192 nonterminal ParseNode quantifier;
193 nonterminal ParseNode inclusion;
194 nonterminal ParseNode expr;
195 nonterminal ParseNode literal;
197 nonterminal ParseNode simple_expr;
198 nonterminal ParseNode location;
200 nonterminal ParseNode set;
201 nonterminal ParseNode listofliterals;
203 precedence nonassoc OR;
204 precedence nonassoc AND;
206 precedence nonassoc EQ, NE;
207 precedence nonassoc LT, LE, GE, GT;
209 precedence left INTEST;
211 precedence left ADD, SUB;
212 precedence left MULT, DIV;
216 // PRODUCTION RULES /////////////////////////////////////////////////////
222 rules:rules rule:rule
224 debugMessage(PRODSTRING);
225 rules.addChild(rule);
231 debugMessage(PRODSTRING);
232 ParseNode rules = new ParseNode("rules", parser.curLine(1));
233 rules.addChild(rule);
240 ruletype:ruletype OPENBRACKET optquantifiers:quantifiers CLOSEBRACKET
241 COMMA expr:guard IMPLIES inclusion:inclusion SEMICOLON
243 debugMessage(PRODSTRING);
244 ParseNode rule = new ParseNode("rule", parser.curLine(9));
245 if (ruletype != null) {
246 rule.addChild(ruletype);
248 if (quantifiers != null) {
249 rule.addChild(quantifiers);
251 rule.addChild(guard);
252 rule.addChild(inclusion);
261 debugMessage(PRODSTRING);
262 RESULT = new ParseNode("static", parser.curLine(1));
267 debugMessage(PRODSTRING);
268 RESULT = new ParseNode("delay", parser.curLine(1));
273 debugMessage(PRODSTRING);
280 quantifiers:quantifiers
282 debugMessage(PRODSTRING);
283 RESULT = quantifiers;
288 debugMessage(PRODSTRING);
295 quantifiers:quantifiers COMMA quantifier:quantifier
297 debugMessage(PRODSTRING);
298 quantifiers.addChild(quantifier);
299 RESULT = quantifiers;
302 | quantifier:quantifier
304 debugMessage(PRODSTRING);
305 ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
306 quantifiers.addChild(quantifier);
307 RESULT = quantifiers;
313 FORALL ID:var IN set:set
315 debugMessage(PRODSTRING);
316 ParseNode q = new ParseNode("quantifier", parser.curLine(4));
317 q.addChild("forall", parser.curLine(4));
318 q.addChild("var", parser.curLine(3)).addChild(var);
323 | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
325 debugMessage(PRODSTRING);
326 ParseNode q = new ParseNode("quantifier", parser.curLine(7));
327 q.addChild("relation", parser.curLine(1)).addChild(relation);
328 q.addChild("left", parser.curLine(5)).addChild(r1);
329 q.addChild("right", parser.curLine(3)).addChild(r2);
333 | FOR ID:var EQ expr:lower TO expr:upper
335 debugMessage(PRODSTRING);
336 ParseNode q = new ParseNode("quantifier", parser.curLine(5));
338 q.addChild("var", parser.curLine(4)).addChild(var);
339 q.addChild("lower", parser.curLine(3)).addChild(lower);
340 q.addChild("upper", parser.curLine(1)).addChild(upper);
347 expr:expr IN ID:setname
349 debugMessage(PRODSTRING);
350 ParseNode set = (new ParseNode("inclusion", parser.curLine(3))).addChild("set");
352 set.addChild("name", parser.curLine(1)).addChild(setname);
353 RESULT = set.getRoot();
356 | LT expr:r1 COMMA expr:r2 GT IN ID:relationname
358 debugMessage(PRODSTRING);
359 ParseNode relation = (new ParseNode("inclusion", parser.curLine(7))).addChild("relation");
360 relation.addChild("left").addChild(r1);
361 relation.addChild("right").addChild(r2);
362 relation.addChild("name", parser.curLine(1)).addChild(relationname);
363 RESULT = relation.getRoot();
371 debugMessage(PRODSTRING);
372 ParseNode se = new ParseNode("simple_expr", parser.curLine(1));
373 se.addChild(location);
382 debugMessage(PRODSTRING);
383 ParseNode loc = new ParseNode("location", parser.curLine(1));
384 loc.addChild("var").addChild(var);
388 | simple_expr:dotexpr DOT ID:field
390 debugMessage(PRODSTRING);
391 ParseNode dot = (new ParseNode("location", parser.curLine(3))).addChild("dot");
392 dot.addChild(dotexpr);
393 dot.addChild("field", parser.curLine(1)).addChild(field);
394 RESULT = dot.getRoot();
397 | simple_expr:dotexpr DOT ID:field OPENBRACKET expr:index CLOSEBRACKET
399 debugMessage(PRODSTRING);
400 ParseNode dot = (new ParseNode("location", parser.curLine(6))).addChild("dot");
401 dot.addChild(dotexpr);
402 dot.addChild("field", parser.curLine(4)).addChild(field);
403 dot.addChild("index", parser.curLine(2)).addChild(index);
404 RESULT = dot.getRoot();
407 | CAST OPENPAREN ID:type COMMA simple_expr:expr CLOSEPAREN
409 debugMessage(PRODSTRING);
410 ParseNode cast = (new ParseNode("location", parser.curLine(6))).addChild("cast");
411 cast.addChild("type").addChild(type);
413 RESULT = cast.getRoot();
421 debugMessage(PRODSTRING);
422 ParseNode expr = new ParseNode("expr", parser.curLine(1));
427 | expr:expr INTEST ID:setname
429 debugMessage(PRODSTRING);
430 ParseNode elementof = (new ParseNode("expr", parser.curLine(3))).addChild("elementof");
431 elementof.addChild(expr);
432 elementof.addChild("name").addChild(setname);
433 RESULT = elementof.getRoot();
436 | LT expr:r1 COMMA expr:r2 GT INTEST ID:relationname
438 debugMessage(PRODSTRING);
439 ParseNode tupleof = (new ParseNode("expr", parser.curLine(7))).addChild("tupleof");
440 tupleof.addChild("left").addChild(r1);
441 tupleof.addChild("right").addChild(r2);
442 tupleof.addChild("name").addChild(relationname);
443 RESULT = tupleof.getRoot();
446 | OPENPAREN expr:expr CLOSEPAREN
448 debugMessage(PRODSTRING);
452 | LITERAL OPENPAREN literal:literal CLOSEPAREN
454 debugMessage(PRODSTRING);
455 ParseNode expr = new ParseNode("expr", parser.curLine(4));
456 expr.addChild(literal);
460 | expr:leftexpr LT expr:rightexpr
462 debugMessage(PRODSTRING);
463 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
464 bool.addChild("op").addChild("lt");
465 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
466 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
467 RESULT = bool.getRoot();
470 | expr:leftexpr LE expr:rightexpr
472 debugMessage(PRODSTRING);
473 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
474 bool.addChild("op").addChild("le");
475 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
476 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
477 RESULT = bool.getRoot();
480 | expr:leftexpr GT expr:rightexpr
482 debugMessage(PRODSTRING);
483 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
484 bool.addChild("op").addChild("gt");
485 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
486 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
487 RESULT = bool.getRoot();
490 | expr:leftexpr GE expr:rightexpr
492 debugMessage(PRODSTRING);
493 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
494 bool.addChild("op").addChild("ge");
495 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
496 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
497 RESULT = bool.getRoot();
500 | expr:leftexpr EQ expr:rightexpr
502 debugMessage(PRODSTRING);
503 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
504 bool.addChild("op").addChild("eq");
505 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
506 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
507 RESULT = bool.getRoot();
510 | expr:leftexpr NE expr:rightexpr
512 debugMessage(PRODSTRING);
513 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
514 bool.addChild("op").addChild("ne");
515 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
516 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
517 RESULT = bool.getRoot();
520 | expr:leftexpr ADD expr:rightexpr
522 debugMessage(PRODSTRING);
523 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
524 bool.addChild("op").addChild("add");
525 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
526 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
527 RESULT = bool.getRoot();
530 | expr:leftexpr SUB expr:rightexpr
532 debugMessage(PRODSTRING);
533 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
534 bool.addChild("op").addChild("sub");
535 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
536 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
537 RESULT = bool.getRoot();
540 | expr:leftexpr DIV expr:rightexpr
542 debugMessage(PRODSTRING);
543 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
544 bool.addChild("op").addChild("div");
545 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
546 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
547 RESULT = bool.getRoot();
550 | expr:leftexpr MULT expr:rightexpr
552 debugMessage(PRODSTRING);
553 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
554 bool.addChild("op").addChild("mult");
555 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
556 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
557 RESULT = bool.getRoot();
560 | expr:leftexpr AND expr:rightexpr
562 debugMessage(PRODSTRING);
563 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
564 bool.addChild("op").addChild("and");
565 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
566 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
567 RESULT = bool.getRoot();
570 | expr:leftexpr OR expr:rightexpr
572 debugMessage(PRODSTRING);
573 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
574 bool.addChild("op").addChild("and");
575 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
576 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
577 RESULT = bool.getRoot();
582 debugMessage(PRODSTRING);
583 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
584 bool.addChild("op").addChild("not");
585 bool.addChild("left").addChild(expr);
586 RESULT = bool.getRoot();
589 | ISVALID OPENPAREN expr:innerexpr CLOSEPAREN
591 debugMessage(PRODSTRING);
592 ParseNode expr = new ParseNode("expr", parser.curLine(4));
593 expr.addChild("isvalid").addChild(innerexpr);
597 | ISVALID OPENPAREN expr:innerexpr COMMA ID:type CLOSEPAREN
599 debugMessage(PRODSTRING);
600 ParseNode isvalid = (new ParseNode("expr", parser.curLine(6))).addChild("isvalid");
601 isvalid.addChild(innerexpr);
602 isvalid.addChild("type", parser.curLine(2)).addChild(type);
603 RESULT = isvalid.getRoot();
607 /** standard *********************************/
613 debugMessage(PRODSTRING);
614 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
619 debugMessage(PRODSTRING);
620 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
625 debugMessage(PRODSTRING);
626 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
631 debugMessage(PRODSTRING);
632 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
637 debugMessage(PRODSTRING);
638 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
643 debugMessage(PRODSTRING);
644 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();
652 debugMessage(PRODSTRING);
653 ParseNode set = new ParseNode("set", parser.curLine(1));
654 set.addChild("name").addChild(setname);
658 | OPENBRACE listofliterals:list CLOSEBRACE
660 debugMessage(PRODSTRING);
661 ParseNode set = new ParseNode("set", parser.curLine(3));
670 listofliterals:list COMMA literal:literal
672 debugMessage(PRODSTRING);
673 list.addChild(literal);
679 debugMessage(PRODSTRING);
680 ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
681 list.addChild(literal);