NF typing and typechecking of unary operators

- Changes to NFTyping.mo and NFTypeCheck.mo for typing and typechecking
  unary operators +, -, not.
- Changes to Absyn.mo - better comment text for unary operators

Author: petfr

Compiler/FrontEnd/Absyn.mo

@@ -720,9 +720,9 @@ uniontype Exp "The Exp uniontype is the container of a Modelica expression.
     Exp exp2;
   end BINARY;
 
-  record UNARY  "Unary operations, e.g. -(x)"
+  record UNARY  "Unary operations, e.g. -(x), +(x)"
     Operator op "op" ;
-    Exp exp "exp Logical binary operations: and, or" ;
+    Exp exp "exp - any arithmetic expression" ;
   end UNARY;
 
   record LBINARY
@@ -733,7 +733,7 @@ uniontype Exp "The Exp uniontype is the container of a Modelica expression.
 
   record LUNARY  "Logical unary operations: not"
     Operator op "op" ;
-    Exp exp "exp Relations, e.g. a >= 0" ;
+    Exp exp "exp - any logical or relation expression" ;
   end LUNARY;
 
   record RELATION

Compiler/NFFrontEnd/NFTypeCheck.mo

@@ -480,6 +480,42 @@ algorithm
   end try;
 end checkLogicalBinaryOperation;
 
+public function checkLogicalUnaryOperation
+  "petfr:
+  Typechecks logical unary operations, i.e. the not operator"
+  input DAE.Exp exp1;
+  input DAE.Type type1;
+  input DAE.Operator operator;
+  output DAE.Exp exp;
+  output DAE.Type ty;
+protected
+  DAE.Exp e1;
+  DAE.Operator op;
+  DAE.TypeSource ty_src;
+  String e1_str, ty1_str, msg_str, op_str, s1;
+algorithm
+  try
+    true := Types.isBoolean(type1);
+    // Logical unary operations here are allowed only on Booleans.
+    ty := type1;
+    op := Expression.setOpType(operator, ty);
+    exp := DAE.LUNARY(op, exp1);
+
+  else
+    e1_str := ExpressionDump.printExpStr(exp1);
+    ty1_str := Types.unparseTypeNoAttr(type1);
+    op_str := DAEDump.dumpOperatorString(operator);
+
+    // Just for proper error messages.
+    msg_str := if not (Types.isBoolean(type1)) then
+      "\n: Logical operations involving non-Boolean types are not valid in Modelica." else ty1_str;
+
+    s1 := "' " + e1_str + op_str  + " '";
+
+    Error.addSourceMessage(Error.UNRESOLVABLE_TYPE, {s1, msg_str}, Absyn.dummyInfo);
+  end try;
+end checkLogicalUnaryOperation;
+
 public function checkRelationOperation
   "mahge:
   Type checks relational operations. Relations on scalars are handled
@@ -531,7 +567,7 @@ public function checkBinaryOperation
   "mahge:
   Type checks binary operations. operations on scalars are handled
   simply by using Types.matchType(). This way conversions from Integer to Real
-  are handled internaly.
+  are handled internally.
   Operations involving arrays and Complex types are handled differently."
   input DAE.Exp exp1;
   input DAE.Type type1;
@@ -610,6 +646,33 @@ algorithm
 end checkBinaryOperation;
 
 
+public function checkUnaryOperation
+  "petfr:
+  Type checks arithmetic unary operations. Both for simple scalar types and
+  operations involving array types. Builds DAE unary node."
+  input DAE.Exp exp1;
+  input DAE.Type type1;
+  input DAE.Operator operator;
+  output DAE.Exp unaryExp;
+  output DAE.Type unaryType;
+protected
+  DAE.Operator op;
+  DAE.TypeSource ty_src;
+  String e1_str, ty1_str, s1;
+algorithm
+  try
+    unaryType := type1;  // ?? correct?, since no type change for unary, see matchType?
+    op := Expression.setOpType(operator, unaryType);
+    unaryExp :=  DAE.UNARY(op, exp1);
+  else
+    e1_str := ExpressionDump.printExpStr(exp1);   // ??Remove possible Error message since Unary?
+    ty1_str := Types.unparseTypeNoAttr(type1);
+    s1 := "' " + e1_str + DAEDump.dumpOperatorSymbol(operator) + " '";
+    Error.addSourceMessage(Error.UNRESOLVABLE_TYPE, {s1, ty1_str}, Absyn.dummyInfo);
+    fail();
+  end try;
+end checkUnaryOperation;
+
 public function checkBinaryOperationArrays
   "mahge:
   Type checks binary operations involving arrays. This involves more checks than

Compiler/NFFrontEnd/NFTyping.mo

@@ -701,6 +701,14 @@ algorithm
       then
         (typedExp, ty, Types.constAnd(var1, var2));
 
+    case Absyn.Exp.UNARY()  // Unary +, -
+      algorithm
+        (e1, ty1, var1) := typeExp(untypedExp.exp, scope, component, info);
+        op := translateOperator(untypedExp.op);
+        (typedExp, ty) := TypeCheck.checkUnaryOperation(e1, ty1, op);
+      then
+        (typedExp, ty, var1);
+
     case Absyn.Exp.LBINARY()
       algorithm
         (e1, ty1, var1) := typeExp(untypedExp.exp1, scope, component, info);
@@ -711,6 +719,14 @@ algorithm
       then
         (typedExp, ty, Types.constAnd(var1, var2));
 
+    case Absyn.Exp.LUNARY()  // Unary not
+      algorithm
+        (e1, ty1, var1) := typeExp(untypedExp.exp, scope, component, info);
+        op := translateOperator(untypedExp.op);
+        (typedExp, ty) := TypeCheck.checkLogicalUnaryOperation(e1, ty1, op);
+      then
+        (typedExp, ty, var1);
+
     case Absyn.Exp.RELATION()
       algorithm
         (e1, ty1, var1) := typeExp(untypedExp.exp1, scope, component, info);

Compiler/boot/Makefile.common

@@ -103,10 +103,10 @@ make-bootstrap-tarball: clean
 	xz --best --force bootstrap-sources.tar
 
 templates:
-	$(MAKE) -f $(defaultMakefileTarget) --no-print-directory -C $(TOP_DIR)/Compiler/Template
+	$(MAKE) -f $(defaultMakefileTarget) --no-print-directory -C $(TOP_DIR)/Compiler/Template OMBUILDDIR=$(OMBUILDDIR)
 
 scripting:
-	$(MAKE) -f $(defaultMakefileTarget) --no-print-directory -C $(TOP_DIR)/Compiler/Script
+	$(MAKE) -f $(defaultMakefileTarget) --no-print-directory -C $(TOP_DIR)/Compiler/Script OMBUILDDIR=$(OMBUILDDIR)
 
 clean:
 	rm -rf $(GEN_DIR)