Oops...forgot the grammar changes...

[repair.git] / Repair / RepairCompiler / MCC / CDL.cup

diff --git a/Repair/RepairCompiler/MCC/CDL.cup b/Repair/RepairCompiler/MCC/CDL.cup
index bb7cfe34461e7b289ce59c4d49aaee9ab35c1fc2..cc67fbe387d78d07d0d5293ea906f0d03a9d4d61 100755 (executable)
--- a/Repair/RepairCompiler/MCC/CDL.cup
+++ b/Repair/RepairCompiler/MCC/CDL.cup
@@ -56,13 +56,29 @@ action code {:
 init with {: :}
 
 parser code {:
+
+       public String filename;
        
        public void syntax_error (java_cup.runtime.Symbol current) {
 
                CUP$CDLParser$actions.errors = true;
                Symbol symbol = (Symbol) current;
-               report_error("CDL: Syntax error at line " + (symbol.line + 1)
-               + ", column " + LineCount.getColumn(symbol.left) + ": " + current.value, current);
+
+               boolean isInteger = true;
+               try{ 
+                   Integer.parseInt(current.value.toString());
+               } catch(NumberFormatException e) { isInteger = false;}
+
+                report_error(filename+":"+(symbol.line+1)+": Syntax error at column " 
+                + (LineCount.getColumn(symbol.left)+1) +": " + current.value, current);
+
+               /*
+               if (current.value.equals("true") || isInteger)
+                  System.out.println("Did you mean literal("+current.value+")?");
+               */
+
+               System.out.println();
+               System.exit(0);
        }
 
        public void report_fatal_error (String message, Object info) {
@@ -143,6 +159,7 @@ parser code {:
 
     terminal IMPLIES;
     terminal TRUE;
+    terminal FALSE;
     terminal ISVALID;
     terminal FOR;
     terminal TO;
@@ -158,6 +175,7 @@ parser code {:
     terminal LABEL;
     terminal INT;
     terminal SUBTYPE;
+    terminal SUBCLASS;
     terminal OF;
 
     terminal SEMICOLON;
@@ -201,11 +219,14 @@ nonterminal       ParseNode               operator;
 
 precedence left OR;
 precedence left AND;
-precedence right EQ, NE; 
-precedence right LT, LE, GE, GT;
+precedence left EQ, NE; 
+precedence left LT, LE, GE, GT;
+
 precedence left ADD, SUB;
 precedence left MULT, DIV;
+
 precedence left NOT;
+
 precedence left DOT, DOTINV;
 
 // PRODUCTION RULES  /////////////////////////////////////////////////////
@@ -295,6 +316,15 @@ quantifier ::=
        q.addChild(set);
        RESULT = q;
        :}
+       | FORALL LT ID:r1 COMMA ID:r2 GT IN ID:relation
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode q = new ParseNode("quantifier", parser.curLine(7));
+       q.addChild("relation", parser.curLine(1)).addChild(relation);
+       q.addChild("left", parser.curLine(5)).addChild(r1);
+       q.addChild("right", parser.curLine(3)).addChild(r2);
+       RESULT = q;
+       :}
        ;
 
 set ::=
@@ -379,34 +409,25 @@ body ::=
 
 predicate ::=
 
-       ID:var IN setexpr:setexpr
+       expr:expr IN setexpr:setexpr
        {:
        debugMessage(PRODSTRING);
        ParseNode inclusion = (new ParseNode("predicate", parser.curLine(3))).addChild("inclusion");
-       inclusion.addChild("quantifiervar", parser.curLine(3)).addChild(var);
+       inclusion.addChild(expr);
        inclusion.addChild(setexpr);
        RESULT = inclusion.getRoot();
        :}
      
-       | SIZEOF OPENPAREN setexpr:setexpr CLOSEPAREN compare:compare DECIMAL:dec
-       {:
-       ParseNode sizeof = (new ParseNode("predicate", parser.curLine(4))).addChild("sizeof");
-       sizeof.addChild(setexpr);
-       sizeof.addChild("compare", parser.curLine(2)).addChild(compare);
-       sizeof.addChild("decimal", parser.curLine(1)).addChild(dec);
-       RESULT = sizeof.getRoot();
-       :}
-
-       | ID:var DOT ID:relation compare:compare expr:expr
+       | expr:lexpr compare:compare expr:rexpr
        {:
        debugMessage(PRODSTRING);
-       ParseNode comparison = (new ParseNode("predicate", parser.curLine(3))).addChild("comparison");
-       comparison.addChild("compare", parser.curLine(2)).addChild(compare);
-       comparison.addChild("relation", parser.curLine(3)).addChild(relation);
-       comparison.addChild("quantifier", parser.curLine(5)).addChild(var);
-       comparison.addChild(expr);
+       ParseNode comparison = (new ParseNode("predicate", parser.curLine(3))).addChild("expr").addChild("operator");
+       comparison.addChild("op").addChild(compare);
+       comparison.addChild("left", parser.curLine(2)).addChild(lexpr);
+       comparison.addChild("right", parser.curLine(2)).addChild(rexpr);
        RESULT = comparison.getRoot();
        :}
+
        ;
 
 setexpr ::=
@@ -436,6 +457,24 @@ setexpr ::=
        set.getChild("dotinv").addChild("relation", parser.curLine(1)).addChild(relation);
        RESULT = set;
        :}
+
+       | setexpr:setexpr DOT ID:relation
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode set = new ParseNode("setexpr", parser.curLine(3));
+       set.addChild("dotset").addChild(setexpr);
+       set.getChild("dotset").addChild("relation", parser.curLine(1)).addChild(relation);
+       RESULT = set;
+       :}
+
+       | setexpr:setexpr DOTINV ID:relation
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode set = new ParseNode("setexpr", parser.curLine(3));
+       set.addChild("dotinvset").addChild(setexpr);
+       set.getChild("dotinvset").addChild("relation", parser.curLine(1)).addChild(relation);
+       RESULT = set;
+       :}
        ;
        
 expr ::=
@@ -454,7 +493,7 @@ expr ::=
        RESULT = expr;
        :}     
        
-       | LITERAL OPENPAREN literal:literal CLOSEPAREN
+       | literal:literal
        {:
        debugMessage(PRODSTRING);
        ParseNode expr = new ParseNode("expr", parser.curLine(4));
@@ -573,6 +612,18 @@ literal ::=
        RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
        :}
         
+       | FALSE
+       {:
+       debugMessage(PRODSTRING);
+       RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
+       :}
+
+       | NULL
+       {:
+       debugMessage(PRODSTRING);
+       RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild("0").getRoot();
+       :}
+        
        | DECIMAL:dec
        {:
        debugMessage(PRODSTRING);
@@ -591,7 +642,7 @@ literal ::=
        RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
        :}
         
-       | ID:literal
+       | LITERAL OPENPAREN ID:literal CLOSEPAREN
        {:
        debugMessage(PRODSTRING);
        RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();