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;
203 // NON-TERMINALS /////////////////////////////////////////////////////////
207 ------------------------------------------------------------------------*/
209 nonterminal ParseNode rules;
210 nonterminal ParseNode rule;
211 nonterminal ParseNode ruletype;
212 nonterminal ParseNode optquantifiers;
213 nonterminal ParseNode quantifiers;
214 nonterminal ParseNode quantifier;
215 nonterminal ParseNode inclusion;
216 nonterminal ParseNode expr;
217 nonterminal ParseNode literal;
219 nonterminal ParseNode simple_expr;
220 nonterminal ParseNode location;
222 nonterminal ParseNode set;
223 nonterminal ParseNode listofliterals;
225 precedence nonassoc OR;
226 precedence nonassoc AND;
228 precedence nonassoc EQ, NE;
229 precedence nonassoc LT, LE, GE, GT;
231 precedence left INTEST;
233 precedence left ADD, SUB;
234 precedence left MULT, DIV;
238 // PRODUCTION RULES /////////////////////////////////////////////////////
244 rules:rules rule:rule
246 debugMessage(PRODSTRING);
247 rules.addChild(rule);
253 debugMessage(PRODSTRING);
254 ParseNode rules = new ParseNode("rules", parser.curLine(1));
255 rules.addChild(rule);
262 ruletype:ruletype OPENBRACKET optquantifiers:quantifiers CLOSEBRACKET
263 COMMA expr:guard IMPLIES inclusion:inclusion SEMICOLON
265 debugMessage(PRODSTRING);
266 ParseNode rule = new ParseNode("rule", parser.curLine(9));
267 if (ruletype != null) {
268 rule.addChild(ruletype);
270 if (quantifiers != null) {
271 rule.addChild(quantifiers);
273 rule.addChild(guard);
274 rule.addChild(inclusion);
283 debugMessage(PRODSTRING);
284 RESULT = new ParseNode("static", parser.curLine(1));
289 debugMessage(PRODSTRING);
290 RESULT = new ParseNode("delay", parser.curLine(1));
295 debugMessage(PRODSTRING);
302 quantifiers:quantifiers
304 debugMessage(PRODSTRING);
305 RESULT = quantifiers;
310 debugMessage(PRODSTRING);
317 quantifiers:quantifiers COMMA quantifier:quantifier
319 debugMessage(PRODSTRING);
320 quantifiers.addChild(quantifier);
321 RESULT = quantifiers;
324 | quantifier:quantifier
326 debugMessage(PRODSTRING);
327 ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
328 quantifiers.addChild(quantifier);
329 RESULT = quantifiers;
335 FORALL ID:var IN set:set
337 debugMessage(PRODSTRING);
338 ParseNode q = new ParseNode("quantifier", parser.curLine(4));
339 q.addChild("forall", parser.curLine(4));
340 q.addChild("var", parser.curLine(3)).addChild(var);
345 | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
347 debugMessage(PRODSTRING);
348 ParseNode q = new ParseNode("quantifier", parser.curLine(7));
349 q.addChild("relation", parser.curLine(1)).addChild(relation);
350 q.addChild("left", parser.curLine(5)).addChild(r1);
351 q.addChild("right", parser.curLine(3)).addChild(r2);
355 | FOR ID:var EQ expr:lower TO expr:upper
357 debugMessage(PRODSTRING);
358 ParseNode q = new ParseNode("quantifier", parser.curLine(5));
360 q.addChild("var", parser.curLine(4)).addChild(var);
361 q.addChild("lower", parser.curLine(3)).addChild(lower);
362 q.addChild("upper", parser.curLine(1)).addChild(upper);
369 expr:expr IN ID:setname
371 debugMessage(PRODSTRING);
372 ParseNode set = (new ParseNode("inclusion", parser.curLine(3))).addChild("set");
374 set.addChild("name", parser.curLine(1)).addChild(setname);
375 RESULT = set.getRoot();
378 | LT expr:r1 COMMA expr:r2 GT IN ID:relationname
380 debugMessage(PRODSTRING);
381 ParseNode relation = (new ParseNode("inclusion", parser.curLine(7))).addChild("relation");
382 relation.addChild("left").addChild(r1);
383 relation.addChild("right").addChild(r2);
384 relation.addChild("name", parser.curLine(1)).addChild(relationname);
385 RESULT = relation.getRoot();
393 debugMessage(PRODSTRING);
394 ParseNode se = new ParseNode("simple_expr", parser.curLine(1));
395 se.addChild(location);
404 debugMessage(PRODSTRING);
405 ParseNode loc = new ParseNode("location", parser.curLine(1));
406 loc.addChild("var").addChild(var);
410 | simple_expr:dotexpr DOT ID:field
412 debugMessage(PRODSTRING);
413 ParseNode dot = (new ParseNode("location", parser.curLine(3))).addChild("dot");
414 dot.addChild(dotexpr);
415 dot.addChild("field", parser.curLine(1)).addChild(field);
416 RESULT = dot.getRoot();
419 | simple_expr:dotexpr DOT ID:field OPENBRACKET expr:index CLOSEBRACKET
421 debugMessage(PRODSTRING);
422 ParseNode dot = (new ParseNode("location", parser.curLine(6))).addChild("dot");
423 dot.addChild(dotexpr);
424 dot.addChild("field", parser.curLine(4)).addChild(field);
425 dot.addChild("index", parser.curLine(2)).addChild(index);
426 RESULT = dot.getRoot();
429 | CAST OPENPAREN ID:type COMMA simple_expr:expr CLOSEPAREN
431 debugMessage(PRODSTRING);
432 ParseNode cast = (new ParseNode("location", parser.curLine(6))).addChild("cast");
433 cast.addChild("type").addChild(type);
435 RESULT = cast.getRoot();
443 debugMessage(PRODSTRING);
444 ParseNode expr = new ParseNode("expr", parser.curLine(1));
449 | expr:expr INTEST ID:setname
451 debugMessage(PRODSTRING);
452 ParseNode elementof = (new ParseNode("expr", parser.curLine(3))).addChild("elementof");
453 elementof.addChild(expr);
454 elementof.addChild("name").addChild(setname);
455 RESULT = elementof.getRoot();
458 | LT expr:r1 COMMA expr:r2 GT INTEST ID:relationname
460 debugMessage(PRODSTRING);
461 ParseNode tupleof = (new ParseNode("expr", parser.curLine(7))).addChild("tupleof");
462 tupleof.addChild("left").addChild(r1);
463 tupleof.addChild("right").addChild(r2);
464 tupleof.addChild("name").addChild(relationname);
465 RESULT = tupleof.getRoot();
468 | OPENPAREN expr:expr CLOSEPAREN
470 debugMessage(PRODSTRING);
476 debugMessage(PRODSTRING);
477 ParseNode expr = new ParseNode("expr", parser.curLine(4));
478 expr.addChild(literal);
483 | expr:leftexpr LT expr:rightexpr
485 debugMessage(PRODSTRING);
486 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
487 bool.addChild("op").addChild("lt");
488 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
489 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
490 RESULT = bool.getRoot();
493 | expr:leftexpr LE expr:rightexpr
495 debugMessage(PRODSTRING);
496 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
497 bool.addChild("op").addChild("le");
498 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
499 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
500 RESULT = bool.getRoot();
503 | expr:leftexpr GT expr:rightexpr
505 debugMessage(PRODSTRING);
506 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
507 bool.addChild("op").addChild("gt");
508 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
509 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
510 RESULT = bool.getRoot();
513 | expr:leftexpr GE expr:rightexpr
515 debugMessage(PRODSTRING);
516 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
517 bool.addChild("op").addChild("ge");
518 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
519 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
520 RESULT = bool.getRoot();
523 | expr:leftexpr EQ expr:rightexpr
525 debugMessage(PRODSTRING);
526 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
527 bool.addChild("op").addChild("eq");
528 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
529 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
530 RESULT = bool.getRoot();
533 | expr:leftexpr NE expr:rightexpr
535 debugMessage(PRODSTRING);
536 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
537 bool.addChild("op").addChild("ne");
538 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
539 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
540 RESULT = bool.getRoot();
543 | expr:leftexpr ADD expr:rightexpr
545 debugMessage(PRODSTRING);
546 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
547 bool.addChild("op").addChild("add");
548 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
549 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
550 RESULT = bool.getRoot();
553 | expr:leftexpr SUB expr:rightexpr
555 debugMessage(PRODSTRING);
556 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
557 bool.addChild("op").addChild("sub");
558 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
559 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
560 RESULT = bool.getRoot();
563 | expr:leftexpr DIV expr:rightexpr
565 debugMessage(PRODSTRING);
566 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
567 bool.addChild("op").addChild("div");
568 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
569 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
570 RESULT = bool.getRoot();
573 | expr:leftexpr MULT expr:rightexpr
575 debugMessage(PRODSTRING);
576 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
577 bool.addChild("op").addChild("mult");
578 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
579 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
580 RESULT = bool.getRoot();
583 | expr:leftexpr AND expr:rightexpr
585 debugMessage(PRODSTRING);
586 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
587 bool.addChild("op").addChild("and");
588 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
589 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
590 RESULT = bool.getRoot();
593 | expr:leftexpr OR expr:rightexpr
595 debugMessage(PRODSTRING);
596 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
597 bool.addChild("op").addChild("or");
598 bool.addChild("left", parser.curLine(3)).addChild(leftexpr);
599 bool.addChild("right", parser.curLine(1)).addChild(rightexpr);
600 RESULT = bool.getRoot();
605 debugMessage(PRODSTRING);
606 ParseNode bool = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
607 bool.addChild("op").addChild("not");
608 bool.addChild("left").addChild(expr);
609 RESULT = bool.getRoot();
612 | ISVALID OPENPAREN expr:innerexpr CLOSEPAREN
614 debugMessage(PRODSTRING);
615 ParseNode expr = new ParseNode("expr", parser.curLine(4));
616 expr.addChild("isvalid").addChild(innerexpr);
620 | ISVALID OPENPAREN expr:innerexpr COMMA ID:type CLOSEPAREN
622 debugMessage(PRODSTRING);
623 ParseNode isvalid = (new ParseNode("expr", parser.curLine(6))).addChild("isvalid");
624 isvalid.addChild(innerexpr);
625 isvalid.addChild("type", parser.curLine(2)).addChild(type);
626 RESULT = isvalid.getRoot();
630 /** standard *********************************/
636 debugMessage(PRODSTRING);
637 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
642 debugMessage(PRODSTRING);
643 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
648 debugMessage(PRODSTRING);
649 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild("0").getRoot();
654 debugMessage(PRODSTRING);
655 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
660 debugMessage(PRODSTRING);
661 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
666 debugMessage(PRODSTRING);
667 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
670 | LITERAL OPENPAREN ID:literal CLOSEPAREN
672 debugMessage(PRODSTRING);
673 RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();
681 debugMessage(PRODSTRING);
682 ParseNode set = new ParseNode("set", parser.curLine(1));
683 set.addChild("name").addChild(setname);
687 | OPENBRACE listofliterals:list CLOSEBRACE
689 debugMessage(PRODSTRING);
690 ParseNode set = new ParseNode("set", parser.curLine(3));
699 listofliterals:list COMMA literal:literal
701 debugMessage(PRODSTRING);
702 list.addChild(literal);
708 debugMessage(PRODSTRING);
709 ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
710 list.addChild(literal);