- Removed strict RML checks.

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

Author: perost

Compiler/FrontEnd/InstFunction.mo

@@ -278,7 +278,6 @@ algorithm
     case (cache,env,ih,mod,pre,(c as SCode.CLASS(restriction = r,partialPrefix = pPrefix)),inst_dims)
       equation
         failure(SCode.R_RECORD(_) = r);
-        true = MetaUtil.strictRMLCheck(Flags.isSet(Flags.STRICT_RML),c);
         (cache,env,ih,funs) = implicitFunctionInstantiation2(cache,env,ih,mod,pre,c,inst_dims,false);
         cache = InstUtil.addFunctionsToDAE(cache, funs, pPrefix);
       then (cache,env,ih);

Compiler/FrontEnd/MetaUtil.mo

@@ -639,92 +639,5 @@ algorithm
   end match;
 end tryToConvertArrayToList;
 
-public function strictRMLCheck
-"If we are checking for strict RML, and function containing a single statement
-that is a match expression must be on the form (outputs) := matchcontinue (inputs).
-RML does not check this even though it's translated to this internally, so we
-must check for it to warn the user."
-  input Boolean b;
-  input SCode.Element c;
-  output Boolean isOK;
-algorithm
-  isOK := matchcontinue (b,c)
-    local
-      list<SCode.Element> elts,inelts,outelts;
-      list<String> innames,outnames;
-      list<Absyn.Exp> outcrefs,increfs;
-      Absyn.Exp comp,inputs;
-      Absyn.Info info;
-    case (false,_) then true;
-    case (_,SCode.CLASS(info = info, restriction = SCode.R_FUNCTION(SCode.FR_NORMAL_FUNCTION(_)), classDef = SCode.PARTS(elementLst = elts, normalAlgorithmLst = {SCode.ALGORITHM({SCode.ALG_ASSIGN(assignComponent = comp, value = Absyn.MATCHEXP(inputExp = inputs))})})))
-      equation
-        outcrefs = extractListFromTuple(comp,0);
-        increfs = extractListFromTuple(inputs,0);
-        inelts = List.select1(elts, SCode.isComponentWithDirection, Absyn.INPUT());
-        outelts = List.select1(elts, SCode.isComponentWithDirection, Absyn.OUTPUT());
-        innames = List.map(inelts, SCode.elementName);
-        outnames = List.map(outelts, SCode.elementName);
-      then strictRMLCheck2(increfs,outcrefs,innames,outnames,info);
-    else true;
-  end matchcontinue;
-end strictRMLCheck;
-
-protected function strictRMLCheck2
-"If we are checking for strict RML, and function containing a single statement
-that is a match expression must be on the form (outputs) := matchcontinue (inputs).
-RML does not check this even though it's translated to this internally, so we
-must check for it to warn the user."
-  input list<Absyn.Exp> increfs;
-  input list<Absyn.Exp> outcrefs;
-  input list<String> innames;
-  input list<String> outnames;
-  input Absyn.Info info;
-  output Boolean b;
-algorithm
-  b := matchcontinue (increfs,outcrefs,innames,outnames,info)
-    local
-      list<String> names;
-    case (_,_,_,_,_)
-      equation
-        true = (listLength(increfs) <> listLength(innames));
-        Error.addSourceMessage(Error.META_STRICT_RML_MATCH_IN_OUT, {"Number of input arguments don't match"}, info);
-      then false;
-    case (_,_,_,_::_,_)
-      equation
-        true = (listLength(outcrefs) <> listLength(outnames));
-        Error.addSourceMessage(Error.META_STRICT_RML_MATCH_IN_OUT, {"Number of output arguments don't match"}, info);
-      then false;
-    case (_,_,_,_,_)
-      equation
-        false = (listLength(outnames)+listLength(innames)) == listLength(List.union(innames,outnames));
-        Error.addSourceMessage(Error.META_STRICT_RML_MATCH_IN_OUT, {"An argument in the output has the same name as one in the input"}, info);
-      then false;
-    case (_,_,_,_,_)
-      equation
-        failure(_ = List.map(increfs, Absyn.expCref));
-        Error.addSourceMessage(Error.META_STRICT_RML_MATCH_IN_OUT, {"Input expression was not a tuple of component references"}, info);
-      then false;
-    case (_,_,_,_,_)
-      equation
-        failure(_ = List.map(outcrefs, Absyn.expCref));
-        Error.addSourceMessage(Error.META_STRICT_RML_MATCH_IN_OUT, {"Output expression was not a tuple of component references"}, info);
-      then false;
-    case (_,_,_,_,_)
-      equation
-        names = List.map(increfs, Absyn.expComponentRefStr);
-        failure(equality(names = innames));
-        Error.addSourceMessage(Error.META_STRICT_RML_MATCH_IN_OUT, {"The input does not match"}, info);
-      then false;
-    case (_,{Absyn.CREF(Absyn.WILD())},_,{},_) then true;
-    case (_,_,_,_,_)
-      equation
-        names = List.map(outcrefs, Absyn.expComponentRefStr);
-        failure(equality(names = outnames));
-        Error.addSourceMessage(Error.META_STRICT_RML_MATCH_IN_OUT, {"The output does not match"}, info);
-      then false;
-    else true;
-  end matchcontinue;
-end strictRMLCheck2;
-
 annotation(__OpenModelica_Interface="frontend");
 end MetaUtil;

Compiler/FrontEnd/ModelicaBuiltin.mo

@@ -1702,12 +1702,6 @@ external "builtin";
 annotation(preferredView="text");
 end getClassesInModelicaPath;
 
-function strictRMLCheck "Checks if any loaded function."
-  output String message "empty if there was no problem";
-external "builtin";
-annotation(preferredView="text");
-end strictRMLCheck;
-
 /* These don't influence anything...
 function getClassNamesForSimulation
   output String classNamesForSimulation;

Compiler/Script/CevalScript.mo

@@ -3332,13 +3332,6 @@ algorithm
         setEcho(bval);
       then (cache,v,st);
 
-    case (cache,_,"strictRMLCheck",_,st as GlobalScript.SYMBOLTABLE(ast = p),_)
-      equation
-        _ = List.map1r(List.map(Interactive.getFunctionsInProgram(p), SCodeUtil.translateClass), MetaUtil.strictRMLCheck, true);
-        str = Error.printMessagesStr(false);
-        v = Values.STRING(str);
-      then (cache,v,st);
-
     case (cache,env,"dumpXMLDAE",vals,st,_)
       equation
         (cache,st,xml_filename) = dumpXMLDAE(cache,env,vals,st, msg);

Compiler/Util/Error.mo

@@ -801,8 +801,6 @@ public constant Message META_MATCH_GENERAL_FAILURE = MESSAGE(5014, TRANSLATION()
   Util.gettext("Failed to elaborate match expression %s"));
 public constant Message META_CONS_TYPE_MATCH = MESSAGE(5015, TRANSLATION(), ERROR(),
   Util.gettext("Failed to match types of cons expression %s. The head has type %s and the tail %s."));
-public constant Message META_STRICT_RML_MATCH_IN_OUT = MESSAGE(5016, TRANSLATION(), ERROR(),
-  Util.gettext("%s. Strict RML enforces match expression input and output to be the same as the function's."));
 public constant Message META_NONE_CREF = MESSAGE(5017, TRANSLATION(), ERROR(),
   Util.gettext("NONE is not acceptable syntax. Use NONE() instead."));
 public constant Message META_INVALID_PATTERN_NAMED_FIELD = MESSAGE(5018, TRANSLATION(), ERROR(),

Compiler/Util/Flags.mo

@@ -376,41 +376,39 @@ constant DebugFlag EVALUATE_CONST_FUNCTIONS = DEBUG_FLAG(105, "evalConstFuncs",
   Util.gettext("Evaluates functions complete and partially and checks for constant output."));
 constant DebugFlag HPCOM_ANALYZATION_MODE = DEBUG_FLAG(106, "hpcomAnalyzationMode", false,
   Util.gettext("Creates statically linked c++ - code for analyzation (requires statically build cpp-runtime)"));
-constant DebugFlag STRICT_RML = DEBUG_FLAG(107, "strictRml", false,
-  Util.gettext("Turns on extra RML checks."));
-constant DebugFlag IMPL_ODE = DEBUG_FLAG(108, "implOde", false,
+constant DebugFlag IMPL_ODE = DEBUG_FLAG(107, "implOde", false,
   Util.gettext("activates implicit codegen"));
-constant DebugFlag EVAL_FUNC_DUMP = DEBUG_FLAG(109, "evalFuncDump", false,
+constant DebugFlag EVAL_FUNC_DUMP = DEBUG_FLAG(108, "evalFuncDump", false,
   Util.gettext("dumps debug information about the function evaluation"));
-constant DebugFlag PRINT_STRUCTURAL = DEBUG_FLAG(110, "printStructuralParameters", false,
+constant DebugFlag PRINT_STRUCTURAL = DEBUG_FLAG(109, "printStructuralParameters", false,
   Util.gettext("Prints the structural parameters identified by the front-end"));
-constant DebugFlag ITERATION_VARS = DEBUG_FLAG(111, "iterationVars", false,
+constant DebugFlag ITERATION_VARS = DEBUG_FLAG(110, "iterationVars", false,
   Util.gettext("Shows a list of all iteration variables."));
-constant DebugFlag ALLOW_RECORD_TOO_MANY_FIELDS = DEBUG_FLAG(112, "acceptTooManyFields", false,
+constant DebugFlag ALLOW_RECORD_TOO_MANY_FIELDS = DEBUG_FLAG(111, "acceptTooManyFields", false,
   Util.gettext("Accepts passing records with more fields than expected to a function. This is not allowed, but is used in Fluid.Dissipation. See https://trac.modelica.org/Modelica/ticket/1245 for details."));
-constant DebugFlag HPCOM_MEMORY_OPT = DEBUG_FLAG(113, "hpcomMemoryOpt", false,
+constant DebugFlag HPCOM_MEMORY_OPT = DEBUG_FLAG(112, "hpcomMemoryOpt", false,
   Util.gettext("Optimize the memory structure regarding the selected scheduler"));
-constant DebugFlag DUMP_SYNCHRONOUS = DEBUG_FLAG(114, "dumpSynchronous", false,
+constant DebugFlag DUMP_SYNCHRONOUS = DEBUG_FLAG(113, "dumpSynchronous", false,
   Util.gettext("Dumps information of the clock partitioning."));
-constant DebugFlag STRIP_PREFIX = DEBUG_FLAG(115, "stripPrefix", true,
+constant DebugFlag STRIP_PREFIX = DEBUG_FLAG(114, "stripPrefix", true,
   Util.gettext("Strips the environment prefix from path/crefs. Defaults to true."));
-constant DebugFlag DO_SCODE_DEP = DEBUG_FLAG(116, "doSCodeDep", true,
+constant DebugFlag DO_SCODE_DEP = DEBUG_FLAG(115, "doSCodeDep", true,
   Util.gettext("Does scode dependency analysis prior to instantiation. Defaults to true."));
-constant DebugFlag SHOW_INST_CACHE_INFO = DEBUG_FLAG(117, "showInstCacheInfo", false,
+constant DebugFlag SHOW_INST_CACHE_INFO = DEBUG_FLAG(116, "showInstCacheInfo", false,
   Util.gettext("Prints information about instantiation cache hits and additions. Defaults to false."));
-constant DebugFlag DUMP_UNIT = DEBUG_FLAG(118, "dumpUnits", false,
+constant DebugFlag DUMP_UNIT = DEBUG_FLAG(117, "dumpUnits", false,
   Util.gettext("Dumps all the calculated units."));
-constant DebugFlag DUMP_EQ_UNIT = DEBUG_FLAG(119, "dumpEqInUC", false,
+constant DebugFlag DUMP_EQ_UNIT = DEBUG_FLAG(118, "dumpEqInUC", false,
   Util.gettext("Dumps all equations handled by the unit checker."));
-constant DebugFlag DUMP_EQ_UNIT_STRUCT = DEBUG_FLAG(120, "dumpEqUCStruct", false,
+constant DebugFlag DUMP_EQ_UNIT_STRUCT = DEBUG_FLAG(119, "dumpEqUCStruct", false,
   Util.gettext("Dumps all the equations handled by the unit checker as tree-structure."));
-constant DebugFlag SHOW_DAE_GENERATION = DEBUG_FLAG(121, "showDaeGeneration", false,
+constant DebugFlag SHOW_DAE_GENERATION = DEBUG_FLAG(120, "showDaeGeneration", false,
   Util.gettext("Show the dae variable declarations as they happen."));
-constant DebugFlag RESHUFFLE_POST = DEBUG_FLAG(122, "reshufflePost", false,
+constant DebugFlag RESHUFFLE_POST = DEBUG_FLAG(121, "reshufflePost", false,
   Util.gettext("Reshuffles the systems of equations."));
-constant DebugFlag SHOW_EXPANDABLE_INFO = DEBUG_FLAG(123, "showExpandableInfo", false,
+constant DebugFlag SHOW_EXPANDABLE_INFO = DEBUG_FLAG(122, "showExpandableInfo", false,
   Util.gettext("Show information about expandable connector handling."));
-constant DebugFlag DUMP_HOMOTOPY = DEBUG_FLAG(124, "dumpHomotopy", false,
+constant DebugFlag DUMP_HOMOTOPY = DEBUG_FLAG(123, "dumpHomotopy", false,
   Util.gettext("Dumps the results of the postOptModule optimizeHomotopyCalls."));
 
 // This is a list of all debug flags, to keep track of which flags are used. A
@@ -524,7 +522,6 @@ constant list<DebugFlag> allDebugFlags = {
   DUMP_TRANSFORMED_MODELICA_MODEL,
   EVALUATE_CONST_FUNCTIONS,
   HPCOM_ANALYZATION_MODE,
-  STRICT_RML,
   IMPL_ODE,
   EVAL_FUNC_DUMP,
   PRINT_STRUCTURAL,