Adjust to new Operator type.

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@326 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

modeq/connect.rml

@@ -152,17 +152,18 @@ relation equ_equations : Exp.ComponentRef list => DAE.DAEcomp list =
   rule	(* FIXME: check types. Must be real. *)
 	equ_equations y::cs => eq
 	------------------------
-	equ_equations x::y::cs => DAE.EQUATION(Exp.RELATION(Exp.CREF(x),
-							    Exp.REAL_EQUAL,
-							    Exp.CREF(y)))::eq
+	equ_equations x::y::cs
+	  => DAE.EQUATION(Exp.RELATION(Exp.CREF(x),
+				       Exp.EQUAL(Exp.REAL),
+				       Exp.CREF(y)))::eq
 end
 (**)
 relation flow_equations : (Exp.ComponentRef * Face) list => DAE.DAEcomp list =
 
   rule	flow_sum cs => sum
 	------------------
 	flow_equations cs => [DAE.EQUATION(Exp.RELATION(sum,
-							Exp.REAL_EQUAL,
+							Exp.EQUAL(Exp.REAL),
 							Exp.RCONST(0.0)))]
 
 end
@@ -176,14 +177,14 @@ relation flow_sum : (Exp.ComponentRef * Face) list => Exp.Exp =
   rule	sign_flow(c,f) => exp1 &
 	flow_sum cs => exp2
 	------------------
-	flow_sum ((c,f)::cs) => Exp.BINARY(exp1, Exp.REAL_ADD, exp2)
+	flow_sum ((c,f)::cs) => Exp.BINARY(exp1, Exp.ADD(Exp.REAL), exp2)
 
 end
 (**)
 relation sign_flow : (Exp.ComponentRef, Face) => Exp.Exp =
 
   axiom	sign_flow (c,INNER) => Exp.CREF(c)
-  axiom	sign_flow (c,OUTER) => Exp.UNARY(Exp.UMINUS,Exp.CREF(c))
+  axiom	sign_flow (c,OUTER) => Exp.UNARY(Exp.UMINUS(Exp.REAL),Exp.CREF(c))
 
 end
 

modeq/dump.rml

@@ -30,6 +30,7 @@ module Dump:
   relation print_equation: Absyn.Equation => ()
   relation print_algorithm: Absyn.Algorithm => ()
   relation print_list : ('a list, 'a => (), string) => ()
+  relation op_symbol : Absyn.Operator => string
 
 end
 
@@ -436,24 +437,24 @@ relation print_exp: Absyn.Exp => () =
 	-------------
 	print_exp(Absyn.BOOL(true))
 
-  rule	binop_symbol(op) => sym & print_exp e1 & print sym & print_exp e2
+  rule	op_symbol(op) => sym & print_exp e1 & print sym & print_exp e2
 	---------------------------------------------------------------
 	print_exp(Absyn.BINARY(e1, op, e2))
 
-  rule	unaryop_symbol(op) => sym &
+  rule	op_symbol(op) => sym &
 	print sym & print_exp e
 	----------------------------
 	print_exp(Absyn.UNARY(op, e))
 
-  rule	lbinop_symbol(op) => sym & print_exp e1 & print sym & print_exp e2
+  rule	op_symbol(op) => sym & print_exp e1 & print sym & print_exp e2
 	----------------------------------------------------------------
 	print_exp(Absyn.LBINARY(e1, op, e2))
 
-  rule	lunaryop_symbol(op) => sym & print sym & print_exp e
+  rule	op_symbol(op) => sym & print sym & print_exp e
 	---------------------------------------------------
 	print_exp(Absyn.LUNARY(op, e))
 
-  rule	relop_symbol(op) => sym & print_exp(e1) & print sym & print_exp(e2)
+  rule	op_symbol(op) => sym & print_exp(e1) & print sym & print_exp(e2)
 	-----------------------------------------------------------------
 	print_exp(Absyn.RELATION(e1, op, e2))
 
@@ -504,40 +505,32 @@ relation print_row : Absyn.Exp list => () =
 
 end
 
-(** relation: *_symbol
+(** relation: op_symbol
  **
  ** Make a string describing different operators.
  **)
 
-relation binop_symbol : Absyn.BinOp => string =
-  axiom	binop_symbol(Absyn.ADD) => " + "
-  axiom	binop_symbol(Absyn.SUB) => " - "
-  axiom	binop_symbol(Absyn.MUL) => "*"
-  axiom	binop_symbol(Absyn.DIV) => "/"
-  axiom	binop_symbol(Absyn.POW) => "^"
-end
+relation op_symbol : Absyn.Operator => string =
+  axiom	op_symbol(Absyn.ADD) => " + "
+  axiom	op_symbol(Absyn.SUB) => " - "
+  axiom	op_symbol(Absyn.MUL) => "*"
+  axiom	op_symbol(Absyn.DIV) => "/"
+  axiom	op_symbol(Absyn.POW) => "^"
 
-relation unaryop_symbol : Absyn.UnaryOp => string =
-  axiom	unaryop_symbol(Absyn.UMINUS) => "-"
-  axiom	unaryop_symbol(Absyn.UPLUS) => "+"
-end
+  axiom	op_symbol(Absyn.UMINUS) => "-"
+  axiom	op_symbol(Absyn.UPLUS) => "+"
 
-relation lbinop_symbol : Absyn.LBinOp => string =
-  axiom	lbinop_symbol(Absyn.AND) => " AND "
-  axiom	lbinop_symbol(Absyn.OR) => " OR "
-end
+  axiom	op_symbol(Absyn.AND) => " AND "
+  axiom	op_symbol(Absyn.OR) => " OR "
 
-relation lunaryop_symbol : Absyn.LUnaryOp => string =
-  axiom	lunaryop_symbol(Absyn.NOT) => "NOT "
-end
+  axiom	op_symbol(Absyn.NOT) => "NOT "
 
-relation relop_symbol : Absyn.RelOp => string =
-  axiom	relop_symbol(Absyn.LESS)      => " < "
-  axiom	relop_symbol(Absyn.LESSEQ)    => " <= "
-  axiom	relop_symbol(Absyn.GREATER)   => " > "
-  axiom	relop_symbol(Absyn.GREATEREQ) => " >= "
-  axiom	relop_symbol(Absyn.EQUAL)     => " = "
-  axiom	relop_symbol(Absyn.NEQUAL)    => " <> "
+  axiom	op_symbol(Absyn.LESS)      => " < "
+  axiom	op_symbol(Absyn.LESSEQ)    => " <= "
+  axiom	op_symbol(Absyn.GREATER)   => " > "
+  axiom	op_symbol(Absyn.GREATEREQ) => " >= "
+  axiom	op_symbol(Absyn.EQUAL)     => " = "
+  axiom	op_symbol(Absyn.NEQUAL)    => " <> "
 end
 
 (** - Utility relations