- Removed some useless information from the pattern matching algorithm

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

Author: sjoelund

Compiler/DFA.mo

@@ -1465,7 +1465,6 @@ end printSimpleArcs;
 public function matchContinueToSwitch
   input Absyn.MatchType matchType;
   input RenamedPatMatrix2 patMat;
-  input list<list<Absyn.ElementItem>> caseLocalDecls;
   input list<Absyn.Exp> inputVarList; // matchcontinue (var1,var2,...)
   input list<Absyn.ElementItem> declList;
   input list<Absyn.Exp> resVarList;
@@ -1485,15 +1484,14 @@ protected
 algorithm
   (dfaEnv, invalidDecls, cache) := getMatchContinueInvalidDeclsAndInitialEnv(inputVarList, resVarList, cache, localEnv, info);
   Util.SUCCESS() := checkShadowing(declList,invalidDecls,Util.SUCCESS());
-  (outCache, cases) := matchContinueToSwitch2(patMat, caseLocalDecls, inputVarList, resVarList, rhlist, elseRhSide, cache, localEnv, invalidDecls, dfaEnv, info);
+  (outCache, cases) := matchContinueToSwitch2(patMat, inputVarList, resVarList, rhlist, elseRhSide, cache, localEnv, invalidDecls, dfaEnv, info);
   alg := Absyn.ALG_MATCHCASES(matchType,inputVarList,cases);
   algItem := Absyn.ALGORITHMITEM(alg, NONE(), info);
   expr := Absyn.VALUEBLOCK(declList,Absyn.VALUEBLOCKALGORITHMS({algItem}),Absyn.BOOL(true));
 end matchContinueToSwitch;
 
 protected function matchContinueToSwitch2
   input RenamedPatMatrix2 patMat;
-  input list<list<Absyn.ElementItem>> caseLocalDecls;
   input list<Absyn.Exp> inputVarList;
   input list<Absyn.Exp> resVarList;
   input RightHandList rhlist;
@@ -1506,7 +1504,7 @@ protected function matchContinueToSwitch2
   output Env.Cache outCache;
   output list<Absyn.Exp> exprs;
 algorithm
-  (outCache, exprs) := matchcontinue (patMat, caseLocalDecls, inputVarList, resVarList, rhlist, elseRhSide, cache, localEnv, invalidDecls, initialDfaEnv, info)
+  (outCache, exprs) := matchcontinue (patMat, inputVarList, resVarList, rhlist, elseRhSide, cache, localEnv, invalidDecls, initialDfaEnv, info)
     local
       RenamedPatList firstCase;
       RenamedPatMatrix2 restCase;
@@ -1524,34 +1522,34 @@ algorithm
       list<list<Absyn.AlgorithmItem>> caseAlgs;
       list<String> dfaEnvIdents;
 
-    case ({}, {}, _, _, {}, NONE(), localCache, _, _, _, _) then (localCache, {});
+    case ({}, _, _, {}, NONE(), localCache, _, _, _, _) then (localCache, {});
 
-    case ({}, {firstDecls}, _, _, {}, SOME(RIGHTHANDSIDE(_,body,result,_)), localCache, _, _, _, info)
+    case ({}, _, _, {}, SOME(RIGHTHANDSIDE(localList,body,result,_)), localCache, _, _, _, info)
       equation
-        Util.SUCCESS() = checkShadowing(firstDecls,invalidDecls,Util.SUCCESS());
+        Util.SUCCESS() = checkShadowing(localList,invalidDecls,Util.SUCCESS());
         exp2 = createListFromExpression(result,resVarList);
         algs3 = createLastAssignments(resVarList,exp2,info);
         algs = {};
-        els = firstDecls;
+        els = localList;
         expr = Absyn.VALUEBLOCK(els,Absyn.VALUEBLOCKMATCHCASE(algs,body,algs3),Absyn.BOOL(true));
       then (localCache, {expr});
 
-    case (firstCase :: restCase, firstDecls :: restDecls,inputVarList, resVarList, RIGHTHANDSIDE(localList,body,result,_) :: restRh, elseRhSide, localCache, localEnv, invalidDecls, initialDfaEnv, info)
+    case (firstCase :: restCase, inputVarList, resVarList, RIGHTHANDSIDE(localList,body,result,_) :: restRh, elseRhSide, localCache, localEnv, invalidDecls, initialDfaEnv, info)
       equation
         dfaEnv = initialDfaEnv;
-        Util.SUCCESS() = checkShadowing(firstDecls,invalidDecls,Util.SUCCESS());
+        Util.SUCCESS() = checkShadowing(localList,invalidDecls,Util.SUCCESS());
 
         exp2 = createListFromExpression(result,resVarList);
 
         // Create the assignments that assign the return variables
         algs3 = createLastAssignments(resVarList,exp2,info);
         (localCache, dfaEnv, els, algs) = generatePathVarDeclarationsList(firstCase, inputVarList, localCache, localEnv, dfaEnv, info);
-        els = listAppend(els, firstDecls);
+        els = listAppend(els, localList);
         expr = Absyn.VALUEBLOCK(els,Absyn.VALUEBLOCKMATCHCASE(algs,body,algs3),Absyn.BOOL(true));
-        (cache, exp2) = matchContinueToSwitch2(restCase, restDecls, inputVarList, resVarList, restRh, elseRhSide, localCache, localEnv, invalidDecls, initialDfaEnv, info);
+        (cache, exp2) = matchContinueToSwitch2(restCase, inputVarList, resVarList, restRh, elseRhSide, localCache, localEnv, invalidDecls, initialDfaEnv, info);
       then (cache, expr :: exp2);
 
-    case (_,_,_,_,_,_,_,_,_,_,_)
+    case (_,_,_,_,_,_,_,_,_,_)
       equation
         Debug.fprintln("matchcase", "- DFA.matchContinueToSwitch2 failed");
       then fail();

Compiler/Error.mo

@@ -1032,5 +1032,20 @@ algorithm
   end matchcontinue;
 end fixFilenameForTestsuite;
 
+public function assertion
+"Used to make compiler-internal assertions. These messages are not meant
+to be shown to a user, but rather to show internal error messages."
+  input Boolean b;
+  input String message;
+algorithm
+  _ := match (b,message)
+    case (true,_) then ();
+    else
+      equation
+        addMessage(INTERNAL_ERROR, {message});
+      then fail();
+  end match;
+end assertion;
+
 end Error;
 

Compiler/Patternm.mo

@@ -790,7 +790,6 @@ algorithm
         // Get the pattern matrix, etc.
         (localCache,inputVarList,declList,rhList2,rhList,patMat,elseRhSide) = ASTtoMatrixForm(localMatchCont,localCache,localEnv,info);
         Absyn.MATCHEXP(matchTy=matchType,cases=cases) = localMatchCont;
-        caseLocalDeclList = Util.listMap(cases, getCaseDecls);
         patMat2 = arrayList(patMat);
 
         // A small fix.
@@ -815,56 +814,10 @@ algorithm
         // The rhList version is a "light" version of the rightHandSides so that
         // we do not have to carry around a lot of extra code in the pattern match algorithm
         patMat2 = Util.listlistTranspose(patMat2);
-        (localCache, expr) = DFA.matchContinueToSwitch(matchType,patMat2,caseLocalDeclList,inputVarList,declList,localResultVarList,rhList2,elseRhSide,localCache,localEnv,info);
+        // Error.assertion(listLength(patMat2) == listLength(cases), "Patternm.matchmain didn't get a correct matrix");
+        (localCache, expr) = DFA.matchContinueToSwitch(matchType,patMat2,inputVarList,declList,localResultVarList,rhList2,elseRhSide,localCache,localEnv,info);
       then (localCache, expr);
-    /*
 
-    case (localMatchCont,localResultVarList,localCache,localEnv)
-      equation
-        // Get the pattern matrix, etc.
-        (localCache,inputVarList,declList,rhList2,rhList,patMat,elseRhSide) =
-        ASTtoMatrixForm(localMatchCont,localCache,localEnv);
-        patMat2 = arrayList(patMat);
-
-        // A small fix.
-        patMat2 = DFA.matrixFix(patMat2);
-
-        // -------------------
-        // ---Type Checking---
-        // -------------------
-        // Two sorts of type checkings are performed:
-        // - The type of the input variables are looked up
-        //   and matched against the patterns in each case clause
-        // - The type of the return variables are looked up
-        //   and matched against the return expression of each case clause
-        // Check to make sure that the number of patterns in each case-clause
-        // equals the number of input variables is done in the function fillMatrix
-        // -------------
-        //typeCheck1(localCache,localEnv,patMat2,inputVarList);
-        //typeCheck2(localCache,localEnv,rhList2,localResultVarList);
-        // -------------
-
-        // Start the pattern matching
-        // The rhList version is a "light" version of the rightHandSides so that
-        // we do not have to carry around a lot of extra code in the pattern match algorithm
-        (dfaState,stampTemp,_) = matchFuncHelper(patMat2,rhList,DFA.STATE({}),1,{});
-        //print("Done with the matching");
-        nCases = listLength(rhList);
-        dfaRec = DFA.DFArec(declList,{},NONE(),dfaState,stampTemp,nCases);
-
-        // Light version or not ---------------------
-        // In a light version state labels will not be generated.
-        // Light versions are generated when there is only one case-clause
-        // which is the case for instance when we have rhs pattern matching
-        // such as (_,var1,5) = func(...);
-        lightVs = Util.if_((nCases == 1),true,false);
-        //-------------------------------------------
-
-        // Transform the DFA into a valueblock with nested if-elseif-else statements.
-        (localCache,expr) =
-        DFA.fromDFAtoIfNodes(dfaRec,inputVarList,localResultVarList,localCache,localEnv,rhList2,lightVs);
-      then (localCache,expr);
-    */
     case (exp,_,_,_,_)
       equation
 				true = RTOpts.debugFlag("matchcase");