Changes between Version 2 and Version 3 of OpenModelicaStyleGuide

Timestamp:

2015-03-19T16:36:15+01:00 (9 years ago)

Author:

perost

Comment:

--

OpenModelicaStyleGuide

@@ -4 +4 @@
     {{{#!mo
     // Prefer this.
-    case DAE.ARRAY(ty = array_ty)  
+    case DAE.ARRAY(ty = DAE.T_REAL())  
 
     // Not this.
-    case DAE.ARRAY(array_ty, _, _) 
+    case DAE.ARRAY(DAE.T_REAL(), _, _) 
     }}}
-    One exception is when matching all fields in a uniontype, doing some changes to them, and then constructing a new instance of the same type. In that case the code will need to be updated if the uniontype changes anyway, so using positional arguments will give cleaner code.
-    {{{#!mo
-    case DAE.ARRAY(array_ty, is_scalar, expl)
-      equation
-        expl = listRest(expl);
-      then
-        DAE.ARRAY(array_ty, is_scalar, expl)
-    }}}
-  
   Use {{{else}}} for catch-all::
     Prefer using {{{else}}} when writing a catch-all case:
     {{{#!mo
     outValue := match(inExp1, inExp2)
-      local
-        Integer i1, i2;
-
-      case (DAE.ICONST(integer = i1), DAE.ICONST(integer = i2)) then i1 + i2;
+      case (DAE.ICONST(), DAE.ICONST()) then inExp1.integer + inExp2.integer;
       else 0;
 
@@ -53 +41 @@
     end match;
     }}}
+== Error Handling ==
+  Use the appropriate method to handle errors::
+    For errors that are of interest to the user, use one of the Error.addXXXMessage functions to print an error/warning message. Always supply the source info when posssible, i.e. prefer using addSourceMessage or addMultiSourceMessage. For cases where it might be of interest to the developers if a function fails, use failtrace and Debug.traceXXX:
+    {{{#!mo
+    if Flags.isSet(Flags.FAILTRACE) then
+      Debug.traceln("- Foo.bar failed!");
+    end if;
+    }}}
+    For functions that should never fail, use internal errors:
+    {{{#!mo
+    function foo
+      input Integer inN;
+    algorithm
+      if inN < 0 then
+        Error.addInternalError("Negative number given to foo!", sourceInfo());
+      end if;
+    end foo;
+    }}}
+  Only print internal errors as a last resort::
+    Internal errors should only be used when something has gone really wrong, and ideally they should never be shown to users. In many cases it's therefore appropriate to check that some other error hasn't already been printed before printing an internal error:
+    {{{#!mo
+    function foo
+      ...
+    protected
+      Integer err_count = Error.getNumErrorMessages();
+    algorithm
+      try
+        // Something which can fail, and might or might not print an error message if it does fail.
+      else
+        // Only print an internal error if the above code failed without printing an error message.
+        if err_count == Error.getNumErrorMessages() then
+          Error.addInternalError(...);
+        end if;
+      end try;
+    end foo;
+    }}}