finished first rework (untested), changed signal impl. to conj. normalform

build.gradle

@@ -292,7 +292,7 @@ jastadd {
     parser.genDir = "src/gen/java/de/tudresden/inf/st/pnml/jastadd/parser"
 
 //  default options are: '--rewrite=cnta', '--safeLazy', '--visitCheck=false', '--cacheCycle=false'
-    extraJastAddOptions = ['--List=JastAddList'] // '--incremental=param'
+    extraJastAddOptions = ['--List=JastAddList', '--lineColumnNumbers'] // '--incremental=param'
 }
 
 // publish gitlab project

src/data/java/de/tudresden/inf/st/pnml/base/constants/PnmlConstants.java

@@ -35,7 +35,6 @@ public final class PnmlConstants {
     // service related keys
     public static final String TRANSITION_TYPE_SERVICE = "serviceTransitionType";
     public static final String SERVICE_NAME = "serviceName";
-    public static final String SERVICE_INSTANCE = "serviceInstance";
     public static final String TRANSITION_SERVICE_SERVER_IN_KEY = "serverInput";
     public static final String TRANSITION_SERVICE_SERVER_OUT_KEY = "serverOutput";
     public static final String TRANSITION_SERVICE_CHANNELS_KEY = "channels";

src/main/jastadd/base/clauses/ExpressionParser.beaver

@@ -6,22 +6,34 @@ package de.tudresden.inf.st.pnml.jastadd.parser;
 %terminals NOT;
 %terminals LP;
 %terminals RP;
-%terminals VARIABLE;
-%typeof goal = "conjunctions";
-%typeof conjunction = "Conjunction";
+%terminals IDENTIFIER;
+%typeof goal = "disjunctions";
+%typeof disjunction = "Disjunction";
+%typeof disjunction_list = "JastAddList";
+%typeof literal_list = "JastAddList";
+%typeof literal = "Literal";
 %goal goal;
 goal =
-    conjunction.conjunction {: return new Symbol(new InputSignalClause(conjunction)); :}
+    disjunction_list.dl {: return new Symbol(new InputSignalClause(dl)); :}
   ;
-exp =
-    exp.a AND.AND exp.b {: return new Symbol(new AndExp(a, b)); :}
 
-  | exp.a OR.OR exp.b {: return new Symbol(new OrExp(a, b)); :}
+disjunction_list =
+                                               {: return new Symbol(new JastAddList<Disjunction>()); :}
+  | disjunction.d                              {: return new Symbol(new JastAddList<Disjunction>().add(d)); :}
+  | disjunction.d AND disjunction_list.dl      {: return new Symbol(dl.add(d)); :}
+  ;
 
-  | NOT.NOT exp.exp {: return new Symbol(new NotExp(exp)); :}
+disjunction =
+  LP literal_list.ll RP  {: return new Symbol(new Disjunction(ll)); :}
+  ;
 
-  | NOT.NOT Literal.Literal {: return new Symbol(new NegativeLiteral(((String)v.value))); :}
+literal_list =
+  literal.l                                {: return new Symbol(new JastAddList<Literal>().add(l)); :}
+  | literal.l OR literal_list.ll           {: return new Symbol(ll.add(l)); :}
+  ;
 
-  | Literal.Literal {: return new Symbol(new PositiveLiteral(((String)v.value))); :}
+literal =
+  NOT IDENTIFIER.literal {: return new Symbol(new NegativeLiteral(((String)literal.value))); :}
+  | IDENTIFIER.literal   {: return new Symbol(new PositiveLiteral(((String)literal.value))); :}
   ;
 

src/main/jastadd/base/clauses/expressions.flex

@@ -37,5 +37,8 @@ Variable = [:jletter:][:jletterdigit:]*
 "NOT"         { return sym(Terminals.NOT); }
 "("           { return sym(Terminals.LP); }
 ")"           { return sym(Terminals.RP); }
-{Variable}    { return sym(Terminals.VARIABLE); }
+{Variable}    { return sym(Terminals.IDENTIFIER); }
 <<EOF>>       { return sym(Terminals.EOF); }
+
+/* error fallback */
+[^]            { throw new Error("Illegal character '"+ yytext() +"' at line " + (yyline+1) + " column " + (yycolumn+1)); }
\ No newline at end of file

src/main/jastadd/base/clauses/expressions.jadd

@@ -2,28 +2,67 @@ import de.tudresden.inf.st.pnml.base.data.ClauseValuesDefinition;
 
 aspect SignalExpressions {
 
-    syn String ASTNode.printExp();
-    syn boolean Exp.eval(ClauseValuesDefinition defs);
+    syn boolean Literal.isPositiveLiteral() = false;
+    eq PositiveLiteral.isPositiveLiteral() = true;
 
-    eq ASTNode.printExp() = "";
+    syn boolean Literal.isNegativeLiteral() = false;
+    eq NegativeLiteral.isNegativeLiteral() = true;
+
+    syn String ASTNode.printClause();
+    eq ASTNode.printClause() = "";
+    eq Literal.printClause() = getName();
+
+    eq InputSignalClause.printClause() {
 
-    eq InputSignalClause.printExp() {
         String result = "";
+        if(getDisjunctionList() != null){
+
+            int j = 0;
+            for(Disjunction dj : getDisjunctionList()){
+
+                int i = 0;
+                for(Literal l : dj.getLiteralList()){
+                    result += "(";
+                    if(i < dj.getNumLiteral()){
+                        result += l.printClause() + " OR ";
+                    } else {
+                        result += l.printClause();
+                    }
+
+                    result += ")";
+                    i++;
+                }
 
-        if(getExp() != null){
-            result+=getExp().printExp();
+                if(j < getNumDisjunction()){
+                    result += " AND ";
+                }
+                j++;
+            }
         }
         return result;
     }
 
-    eq AndExp.printExp() = getA().printExp() + " AND " + getB().printExp();
-    eq OrExp.printExp()  = getA().printExp() + " OR " + getB().printExp();
-    eq Var.printExp() = getName();
-    eq NotExp.printExp() = "NOT " + getExp().printExp();
+    syn boolean ASTNode.evalClause(ClauseValuesDefinition defs);
+    eq ASTNode.evalClause(ClauseValuesDefinition defs) = false;
 
-    eq AndExp.eval(ClauseValuesDefinition defs) = getA().eval(defs) && getB().eval(defs);
-    eq OrExp.eval(ClauseValuesDefinition defs)  = getA().eval(defs) || getB().eval(defs);
-    eq Var.eval(ClauseValuesDefinition defs) = defs.getDef(this.getName());
-    eq NotExp.eval(ClauseValuesDefinition defs) = !getExp().eval(defs);
+    eq PositiveLiteral.evalClause(ClauseValuesDefinition defs) = defs.getDef(this.getName());
+    eq NegativeLiteral.evalClause(ClauseValuesDefinition defs) = !defs.getDef(this.getName());
 
+    eq Disjunction.evalClause(ClauseValuesDefinition defs) {
+        for(Literal l : getLiteralList()){
+            if(l.evalClause(defs) == true){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    eq InputSignalClause.evalClause(ClauseValuesDefinition defs) {
+        for(Disjunction dj : getDisjunctionList()){
+            if(dj.evalClause(defs) == false){
+                return false;
+            }
+        }
+        return true;
+    }
 }
\ No newline at end of file

src/main/jastadd/base/clauses/expressions.relast

-InputSignalClause ::= Conjuction:Conjunction;
-
-Conjunction ::= Disjunction:Disjunction* ;
+InputSignalClause ::= Disjunction:Disjunction* ;
 Disjunction ::= Literal:Literal*;
 
 abstract Literal ::= <Name:String>;
 PositiveLiteral : Literal;
-NegativeLiteral : Literal;
\ No newline at end of file
+NegativeLiteral : Literal;

src/main/java/de/tudresden/inf/st/pnml/base/Main.java

@@ -5,7 +5,5 @@ public class Main {
     public static void main(String[] args) {
 
         // Nothing to do here
-
-        // TODO: update clauses
     }
 }