diff --git a/sw/tools/fp_parser.mly b/sw/tools/fp_parser.mly
index 402ee6039a..d49fb8a811 100644
--- a/sw/tools/fp_parser.mly
+++ b/sw/tools/fp_parser.mly
@@ -24,16 +24,16 @@ open Fp_syntax
 %%
 
 expression:
-    expression GT expression { Call (">",[$1;$3]) }
-  | expression GEQ expression { Call (">=",[$1;$3]) }
-  | expression EQ expression { Call ("==",[$1;$3]) }
-  | expression AND expression { Call ("&&",[$1;$3]) }
-  | expression PLUS expression { Call ("+",[$1;$3]) }
-  | expression MINUS expression { Call ("-",[$1;$3]) }
-  | expression MULT expression { Call ("*",[$1;$3]) }
-  | expression DIV expression { Call ("/",[$1;$3]) }
-  | MINUS expression %prec UMINUS { Call ("-",[$2]) }
-  | NOT expression { Call ("!",[$2]) }
+    expression GT expression { CallOperator (">",[$1;$3]) }
+  | expression GEQ expression { CallOperator (">=",[$1;$3]) }
+  | expression EQ expression { CallOperator ("==",[$1;$3]) }
+  | expression AND expression { CallOperator ("&&",[$1;$3]) }
+  | expression PLUS expression { CallOperator ("+",[$1;$3]) }
+  | expression MINUS expression { CallOperator ("-",[$1;$3]) }
+  | expression MULT expression { CallOperator ("*",[$1;$3]) }
+  | expression DIV expression { CallOperator ("/",[$1;$3]) }
+  | MINUS expression %prec UMINUS { CallOperator ("-",[$2]) }
+  | NOT expression { CallOperator ("!",[$2]) }
   | INT { Int $1 }
   | FLOAT { Float $1 }
   | IDENT { Ident $1 }
diff --git a/sw/tools/fp_proc.ml b/sw/tools/fp_proc.ml
index 46db0f3432..3f514c48b4 100644
--- a/sw/tools/fp_proc.ml
+++ b/sw/tools/fp_proc.ml
@@ -68,6 +68,9 @@ let rotate_expression = fun a expression ->
     | Call("Qdr", [Int a']) -> Call("Qdr", [Float (float a' +. a)])
     | Call(op, [e1; e2]) when op = "And" || op ="Or" ->
 	Call(op, [rot e1; rot e2]) 
+    | CallOperator(op, [e]) -> CallOperator(op, [rot e])
+    | CallOperator(op, [e1; e2]) -> CallOperator(op, [rot e1; rot e2])
+    | CallOperator(op, _) -> failwith "fp_proc: Operator should be unary or binary"
     | _ -> e in
   rot expression
 
@@ -77,6 +80,7 @@ let subst_expression = fun env e ->
       Ident i -> Ident (try List.assoc i env with Not_found -> i)
     | Int _ | Float _ -> e
     | Call (i, es) -> Call (i, List.map sub es)
+    | CallOperator (i, es) -> CallOperator (i, List.map sub es)
     | Index (i,e) -> Index (i,sub e) in
   sub e
 
diff --git a/sw/tools/fp_syntax.ml b/sw/tools/fp_syntax.ml
index f684cbfe03..2c7e90c415 100644
--- a/sw/tools/fp_syntax.ml
+++ b/sw/tools/fp_syntax.ml
@@ -14,26 +14,28 @@ type expression =
   | Int of int
   | Float of float
   | Call of ident * (expression list)
+  | CallOperator of ident * (expression list)
   | Index of ident * expression
 
 let c_var_of_ident = fun x -> "_var_" ^ x
 
 (* Valid unary and binary opetarors *)
-let binary_operators = ["+"; ">"; "-"; "*"]
+(*let binary_operators = ["+"; ">"; "-"; "*"]
 let unary_operators = ["!"; "-"]
 
 let is_binary = fun op -> List.mem op binary_operators
-let is_unary = fun op -> List.mem op unary_operators
+let is_unary = fun op -> List.mem op unary_operators*)
 
 let rec sprint_expression = function
     Ident i when i.[0] = '$' -> sprintf "%s" (c_var_of_ident (String.sub i 1 (String.length i - 1)))
   | Ident i -> sprintf "%s" i
   | Int i -> sprintf "%d" i
   | Float i -> sprintf "%f" i
-  | Call (op, [e1;e2]) when is_binary op ->
+  | CallOperator (op, [e1;e2]) ->
       sprintf "(" ^ sprint_expression e1 ^ op ^ sprint_expression e2 ^ ")"
-  | Call (op, [e1]) when is_unary op ->
+  | CallOperator (op, [e1]) ->
       sprintf "%s(%s)" op (sprint_expression e1)
+  | CallOperator (_,_) -> failwith "Operator should be binary or unary"
   | Call (i, es) ->
       let ses = List.map sprint_expression es in
       sprintf "%s(" i ^ String.concat "," ses ^ ")"
@@ -45,7 +47,7 @@ let functions = [
   "And";
   "Or";
   "RcEvent1";
-  "RcEvent2"] @ binary_operators @ unary_operators
+  "RcEvent2"] (*@ binary_operators @ unary_operators*)
 
 (* Valid identifiers *)
 let variables = [
@@ -70,7 +72,7 @@ let rec check_expression = fun e ->
   | Ident i ->
       if not (List.mem i variables) then
 	raise (Unknown_ident i)
-  | Int _  | Float _ -> ()
+  | Int _  | Float _ | CallOperator _ -> ()
   | Call (i, es) ->
       if not (List.mem i functions) then
 	raise (Unknown_function i);
diff --git a/sw/tools/fp_syntax.mli b/sw/tools/fp_syntax.mli
index 166a06d25b..276eac3c99 100644
--- a/sw/tools/fp_syntax.mli
+++ b/sw/tools/fp_syntax.mli
@@ -31,6 +31,7 @@ type expression =
   | Int of int
   | Float of float
   | Call of ident * expression list
+  | CallOperator of ident * expression list
   | Index of ident * expression
 
 val c_var_of_ident : ident -> string