Added the name of the file to the error report.
[repair.git] / Repair / RepairCompiler / MCC / CDL.cup
index 37a93bc..e77068d 100755 (executable)
@@ -56,13 +56,15 @@ 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);
+               report_error(filename+":"+(symbol.line+1)+": Syntax error at column " + LineCount.getColumn(symbol.left) +": " + current.value, current);
+               System.exit(0);
        }
 
        public void report_fatal_error (String message, Object info) {
@@ -143,6 +145,7 @@ parser code {:
 
     terminal IMPLIES;
     terminal TRUE;
+    terminal FALSE;
     terminal ISVALID;
     terminal FOR;
     terminal TO;
@@ -192,62 +195,70 @@ nonterminal       ParseNode               literal;
 nonterminal    ParseNode               body;
 nonterminal    ParseNode               predicate;
 nonterminal    ParseNode               setexpr;
-//nonterminal  ParseNode               limitedcompare;
+
 nonterminal    ParseNode               compare;
 nonterminal    ParseNode               expr;
 nonterminal    ParseNode               operator;
-nonterminal    ParseNode               relations;
-//nonterminal  ParseNode               type;
+
+
 
 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  /////////////////////////////////////////////////////
 
 constraints ::=
-           constraints:constraints constraint:constraint
-           {:
-           debugMessage(PRODSTRING);
-           constraints.addChild(constraint);
-           RESULT = constraints;
-           :}
-           | constraint:constraint
-           {:
-           debugMessage(PRODSTRING);
-           ParseNode constraints = new ParseNode("constraints", parser.curLine(1));
-           constraints.addChild(constraint);
-           RESULT = constraints;
-           :}
-           ;
+           
+       constraints:constraints constraint:constraint
+       {:
+       debugMessage(PRODSTRING);
+       constraints.addChild(constraint);
+       RESULT = constraints;
+       :}
+       
+       | constraint:constraint
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode constraints = new ParseNode("constraints", parser.curLine(1));
+       constraints.addChild(constraint);
+       RESULT = constraints;
+       :}
+       ;
 
 constraint ::=
-           optcrash:crash OPENBRACKET quantifiers:quantifiers CLOSEBRACKET COMMA body:body SEMICOLON
-           {:
-           debugMessage(PRODSTRING);
-           ParseNode constraint = new ParseNode("constraint", parser.curLine(7));
-           if (crash != null) {
-            constraint.addChild(crash);
-           }
-           if (quantifiers != null) {
-            constraint.addChild(quantifiers);
-           }
-           constraint.addChild(body);
-           RESULT = constraint;
-           :}
-           ;
+           
+       optcrash:crash OPENBRACKET quantifiers:quantifiers CLOSEBRACKET COMMA body:body SEMICOLON
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode constraint = new ParseNode("constraint", parser.curLine(7));
+       if (crash != null) {
+               constraint.addChild(crash);
+       }
+       if (quantifiers != null) {
+               constraint.addChild(quantifiers);
+       }
+       constraint.addChild(body);
+       RESULT = constraint;
+       :}
+       ;
 
 optcrash ::=
+
         CRASH
         {:
         debugMessage(PRODSTRING);
         RESULT = new ParseNode("crash", parser.curLine(1));
         :}
+
         | /* nothing */
         {:
         debugMessage(PRODSTRING);
@@ -256,76 +267,91 @@ optcrash ::=
         ;
 
 quantifiers ::=
-           quantifiers:quantifiers COMMA quantifier:quantifier
-           {:
-           debugMessage(PRODSTRING);
-           quantifiers.addChild(quantifier);
-           RESULT = quantifiers;
-           :}
            
-           | quantifier:quantifier
-           {:
-           debugMessage(PRODSTRING);
-           ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
-           quantifiers.addChild(quantifier);
-           RESULT = quantifiers;
-           :}
+       quantifiers:quantifiers COMMA quantifier:quantifier
+       {:
+       debugMessage(PRODSTRING);
+       quantifiers.addChild(quantifier);
+       RESULT = quantifiers;
+       :}
+           
+       | quantifier:quantifier
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode quantifiers = new ParseNode("quantifiers", parser.curLine(1));
+       quantifiers.addChild(quantifier);
+       RESULT = quantifiers;
+       :}
            
-           
-           {:
-           debugMessage(PRODSTRING);
-           RESULT = null;
-           :}
-           ;   
+       | 
+       {:
+       debugMessage(PRODSTRING);
+       RESULT = null;
+       :}
+       ;       
 
 quantifier ::= 
-          FORALL ID:var IN set:set
-          {:
-          debugMessage(PRODSTRING);
-          ParseNode q = new ParseNode("quantifier", parser.curLine(4));
-          q.addChild("forall", parser.curLine(4));
-          q.addChild("var", parser.curLine(3)).addChild(var);
-          q.addChild(set);
-          RESULT = q;
-          :}
-          ;
+          
+       FORALL ID:var IN set:set
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode q = new ParseNode("quantifier", parser.curLine(4));
+       q.addChild("forall", parser.curLine(4));
+       q.addChild("var", parser.curLine(3)).addChild(var);
+       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 ::=
-    ID:setname
-    {:
-    debugMessage(PRODSTRING);
-    ParseNode set = new ParseNode("set", parser.curLine(1));
-    set.addChild("name").addChild(setname);
-    RESULT = set;
-    :}
-    | OPENBRACE listofliterals:list CLOSEBRACE
-    {:
-    debugMessage(PRODSTRING);
-    ParseNode set = new ParseNode("set", parser.curLine(3));
-    set.addChild(list);
-    RESULT = set;
-    :}
-    ;
     
+       ID:setname
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode set = new ParseNode("set", parser.curLine(1));
+       set.addChild("name").addChild(setname);
+       RESULT = set;
+       :}
 
+       | OPENBRACE listofliterals:list CLOSEBRACE
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode set = new ParseNode("set", parser.curLine(3));
+       set.addChild(list);
+       RESULT = set;
+       :}
+       ;
+    
 listofliterals ::=
-              listofliterals:list COMMA literal:literal
-              {:
-              debugMessage(PRODSTRING);
-              list.addChild(literal);
-              RESULT = list;
-              :}
-              | literal:literal
-              {: 
-              debugMessage(PRODSTRING);
-              ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
-              list.addChild(literal);
-              RESULT = list;
-              :}
-              ;
+              
+       listofliterals:list COMMA literal:literal
+       {:
+       debugMessage(PRODSTRING);
+       list.addChild(literal);
+       RESULT = list;
+       :}
+              
+       | literal:literal
+       {: 
+       debugMessage(PRODSTRING);
+       ParseNode list = new ParseNode("listofliterals", parser.curLine(1));
+       list.addChild(literal);
+       RESULT = list;
+       :}
+       ;
 
 body ::=
-     body:body1 AND body:body2
+
+       body:body1 AND body:body2
        {:
        debugMessage(PRODSTRING);
        ParseNode body = new ParseNode("body", parser.curLine(3));
@@ -333,7 +359,8 @@ body ::=
        body.getChild("and").addChild("right", parser.curLine(1)).addChild(body2);
        RESULT = body;
        :}
-     | body:body1 OR body:body2
+     
+       | body:body1 OR body:body2
        {:
        debugMessage(PRODSTRING);
        ParseNode body = new ParseNode("body", parser.curLine(3));
@@ -341,57 +368,55 @@ body ::=
        body.getChild("or").addChild("right", parser.curLine(1)).addChild(body2);
        RESULT = body;
        :}
-     | NOT body:body1
+     
+       | NOT body:body1
        {:
        debugMessage(PRODSTRING);
        ParseNode body = new ParseNode("body", parser.curLine(2));
        body.addChild("not").addChild(body1);
        RESULT = body;
        :}
-     | OPENPAREN body:body CLOSEPAREN
+     
+       | OPENPAREN body:body CLOSEPAREN
        {:
        debugMessage(PRODSTRING);
        RESULT = body;
        :}
-     | predicate:predicate
+     
+       | predicate:predicate
        {:
        debugMessage(PRODSTRING);
        ParseNode body = new ParseNode("body", parser.curLine(1));
        body.addChild(predicate);
        RESULT = 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
-       {:
-       ParseNode expr = new ParseNode("expr", parser.curLine(4));
-       expr.addChild("sizeof").addChild(setexpr);
-       RESULT = 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("left", parser.curLine(3)).addChild(leftexpr);
-       comparison.addChild("right", parser.curLine(1)).addChild(rightexpr);
+       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 ::=
+       
        ID:setname
        {:
        debugMessage(PRODSTRING);
@@ -399,6 +424,7 @@ setexpr ::=
        set.addChild("set").addChild(setname);
        RESULT = set;
        :}
+
        | ID:var DOT ID:relation
        {:
        debugMessage(PRODSTRING);
@@ -407,6 +433,7 @@ setexpr ::=
        set.getChild("dot").addChild("relation", parser.curLine(1)).addChild(relation);
        RESULT = set;
        :}
+
        | ID:var DOTINV ID:relation
        {:
        debugMessage(PRODSTRING);
@@ -416,82 +443,51 @@ setexpr ::=
        RESULT = set;
        :}
        ;
-
-
-
-relations ::= 
-        
-        relations:relations DOT ID:relation
-        {:
-        debugMessage(PRODSTRING);
-        relations.insertChild(relation);
-        RESULT = relations;
-        :}
-
-        | relations:relations DOTINV ID:relation
-        {:
-        debugMessage(PRODSTRING);
-        relations.insertChild(relation).addChild("inv");
-        RESULT = relations;
-        :}
-
-        | ID:relation
-        {:
-        debugMessage(PRODSTRING);
-        ParseNode relations = new ParseNode("relations", parser.curLine(1));
-        relations.addChild(relation);
-        RESULT = relations;
-        :}
-        ;
-
+       
 expr ::=
-
-     ID:var
-     {:
-     debugMessage(PRODSTRING);
-     ParseNode expr = new ParseNode("expr", parser.curLine(1));        
-     expr.addChild("var").addChild(var);
-     RESULT = expr;
-     :}
-
-     | OPENPAREN expr:expr CLOSEPAREN 
-     {:
-     debugMessage(PRODSTRING);
-     RESULT = expr;
-     :}     
-
-     | LITERAL OPENPAREN literal:literal CLOSEPAREN
-     {:
-     debugMessage(PRODSTRING);
-     ParseNode expr = new ParseNode("expr", parser.curLine(4));
-     expr.addChild(literal);
-     RESULT = expr;
-     :}
-
-     | ID:var DOT relations:relations
-     {:
-     debugMessage(PRODSTRING);
-     ParseNode expr = new ParseNode("expr", parser.curLine(3));
-     ParseNode relation = new ParseNode("relation");
-     expr.addChild(relation);
-     relation.addChild("quantifiervar", parser.curLine(3)).addChild(var);
-     relation.addChild(relations);
-     RESULT = expr;
-     :}
-
-     | ID:var DOTINV relations:relations
-     {:
-     debugMessage(PRODSTRING);
-     ParseNode expr = new ParseNode("expr", parser.curLine(3));
-     ParseNode relation = new ParseNode("relation");
-     expr.addChild(relation);
-     relation.addChild("quantifiervar", parser.curLine(3)).addChild(var);
-     relation.addChild(relations);
-     relations.getChildren().elementAt(0).addChild("inv");
-     RESULT = expr;
-     :}
        
-     | expr:expr1 operator:operator expr:expr2
+       ID:var
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode expr = new ParseNode("expr", parser.curLine(1));      
+       expr.addChild("var").addChild(var);
+       RESULT = expr;
+       :}
+       
+       | OPENPAREN expr:expr CLOSEPAREN 
+       {:
+       debugMessage(PRODSTRING);
+       RESULT = expr;
+       :}     
+       
+       | LITERAL OPENPAREN literal:literal CLOSEPAREN
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode expr = new ParseNode("expr", parser.curLine(4));
+       expr.addChild(literal);
+       RESULT = expr;
+       :}
+       
+       | expr:expr DOT ID:relname
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode relation = (new ParseNode("expr", parser.curLine(3))).addChild("relation");
+       relation.addChild(expr);
+       relation.addChild("name").addChild(relname);
+       RESULT = relation.getRoot();
+       :}
+       
+       | expr:expr DOTINV ID:relname
+       {:
+       debugMessage(PRODSTRING);
+       ParseNode relation = (new ParseNode("expr", parser.curLine(3))).addChild("relation");
+       relation.addChild(expr);
+       relation.addChild("name").addChild(relname);
+       relation.addChild("inv");
+       RESULT = relation.getRoot();
+       :}
+            
+       | expr:expr1 operator:operator expr:expr2
        {:
        debugMessage(PRODSTRING);
        ParseNode op = (new ParseNode("expr", parser.curLine(3))).addChild("operator");
@@ -501,58 +497,73 @@ expr ::=
        RESULT = op.getRoot();
        :}
 
-
-     ;       
+       | SIZEOF OPENPAREN setexpr:setexpr CLOSEPAREN
+       {:
+       ParseNode sizeof = (new ParseNode("expr", parser.curLine(4))).addChild("sizeof");
+       sizeof.addChild(setexpr);
+       RESULT = sizeof.getRoot();
+       :}
+       ;
 
 operator ::=
-         ADD 
+         
+       ADD 
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("add", parser.curLine(1));
        :}
-         | SUB
+         
+       | SUB
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("sub", parser.curLine(1));
        :}
-         | MULT
+         
+       | MULT
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("mult", parser.curLine(1));
        :}
-         | DIV
+         
+       | DIV
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("div", parser.curLine(1));
        :}
-         ;
+       ;
 
 compare ::= 
+
        LT
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("lt", parser.curLine(1));
        :}
+
        | GT
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("gt", parser.curLine(1));
        :}
+
        | LE
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("le", parser.curLine(1));
        :}
+
        | GE
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("ge", parser.curLine(1));
        :}
+
        | EQ
        {:
        debugMessage(PRODSTRING);
        RESULT = new ParseNode("eq", parser.curLine(1));
        :}
+
        | NE
        {:
        debugMessage(PRODSTRING);
@@ -561,27 +572,38 @@ compare ::=
        ;
        
 literal ::=
-        TRUE
+        
+       TRUE
        {:
        debugMessage(PRODSTRING);
        RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("true").getRoot();
        :}
-        | DECIMAL:dec
+        
+       | FALSE
+       {:
+       debugMessage(PRODSTRING);
+       RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("boolean").addChild("false").getRoot();
+       :}
+        
+       | DECIMAL:dec
        {:
        debugMessage(PRODSTRING);
        RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("decimal").addChild(dec).getRoot();
        :}
-        | STRING:str
+        
+       | STRING:str
        {:
        debugMessage(PRODSTRING);
        RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("string").addChild(str).getRoot();
        :}
-        | CHAR:chr
+        
+       | CHAR:chr
        {:
        debugMessage(PRODSTRING);
        RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("char").addChild(chr).getRoot();
        :}
-        | ID:literal
+        
+       | ID:literal
        {:
        debugMessage(PRODSTRING);
        RESULT = (new ParseNode("literal", parser.curLine(1))).addChild("token").addChild(literal).getRoot();