#2897 Implement continue statements in MetaModelica

sjoelund · sjoelund · commit a327ab48f4c3 · 2014-10-17T07:15:47.000Z
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@22782 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo
@@ -4720,6 +4720,10 @@ algorithm
       then
         traverseStmts(xs, func, extraArg);
 
+    case (((DAE.STMT_CONTINUE(source = _))::xs),_,extraArg)
+      then
+        traverseStmts(xs, func, extraArg);
+
     // MetaModelica extension. KS
     case (((DAE.STMT_FAILURE(body=stmts))::xs),_,extraArg)
       equation
diff --git a/Compiler/FrontEnd/Absyn.mo b/Compiler/FrontEnd/Absyn.mo
@@ -576,6 +576,9 @@ uniontype Algorithm "The Algorithm type describes one algorithm statement in an
     list<AlgorithmItem> elseBody;
   end ALG_TRY;
 
+  record ALG_CONTINUE
+  end ALG_CONTINUE;
+
 end Algorithm;
 
 public
@@ -2395,6 +2398,9 @@ algorithm
     case (ALG_BREAK(), _, _, arg)
       then (inAlg, arg);
 
+    case (ALG_CONTINUE(), _, _, arg)
+      then (inAlg, arg);
+
     case (ALG_FAILURE(algs1), _, _, arg)
       equation
         (algs1, arg) = traverseAlgorithmItemListBidir(algs1, enterFunc, exitFunc, arg);
diff --git a/Compiler/FrontEnd/Algorithm.mo b/Compiler/FrontEnd/Algorithm.mo
@@ -880,6 +880,7 @@ algorithm
     case DAE.STMT_NORETCALL(source=source) then source;
     case DAE.STMT_RETURN(source=source) then source;
     case DAE.STMT_BREAK(source=source) then source;
+    case DAE.STMT_CONTINUE(source=source) then source;
     case DAE.STMT_FAILURE(source=source) then source;
     else
       equation
diff --git a/Compiler/FrontEnd/CheckModel.mo b/Compiler/FrontEnd/CheckModel.mo
@@ -538,6 +538,7 @@ algorithm
     case(DAE.STMT_NORETCALL(exp = _), _, _) then iht;
     case(DAE.STMT_RETURN(_), _, _) then iht;
     case(DAE.STMT_BREAK(_), _, _) then iht;
+    case(DAE.STMT_CONTINUE(_), _, _) then iht;
     case(DAE.STMT_ARRAY_INIT(name=_), _, _) then iht;
     // MetaModelica extension. KS
     case(DAE.STMT_FAILURE(body = stmts), _, _)
diff --git a/Compiler/FrontEnd/DAE.mo b/Compiler/FrontEnd/DAE.mo
@@ -696,6 +696,10 @@ uniontype Statement "There are four kinds of statements:
     ElementSource source "the origin of the component/equation/algorithm" ;
   end STMT_BREAK;
 
+  record STMT_CONTINUE
+    ElementSource source "the origin of the component/equation/algorithm" ;
+  end STMT_CONTINUE;
+
   record STMT_ARRAY_INIT "For function initialization"
     String name;
     Type ty;
diff --git a/Compiler/FrontEnd/DAEUtil.mo b/Compiler/FrontEnd/DAEUtil.mo
@@ -4318,6 +4318,9 @@ algorithm
     case (x as DAE.STMT_BREAK(source=_),_,_,extraArg)
       then (x::{},extraArg);
 
+    case (x as DAE.STMT_CONTINUE(source=_),_,_,extraArg)
+      then (x::{},extraArg);
+
     // MetaModelica extension. KS
     case (DAE.STMT_FAILURE(body=stmts, source = source),_,_,extraArg)
       equation
@@ -4524,6 +4527,11 @@ algorithm
         (xs_1, extraArg) = traverseDAEStmts(xs, func, extraArg);
       then (x::xs_1,extraArg);
 
+    case (((x as DAE.STMT_CONTINUE(source=_))::xs),_,extraArg)
+      equation
+        (xs_1, extraArg) = traverseDAEStmts(xs, func, extraArg);
+      then (x::xs_1,extraArg);
+
     // MetaModelica extension. KS
     case (((DAE.STMT_FAILURE(body=stmts, source = source))::xs),_,extraArg)
       equation
diff --git a/Compiler/FrontEnd/InstSection.mo b/Compiler/FrontEnd/InstSection.mo
@@ -2627,6 +2627,13 @@ algorithm
       then
         (cache,{stmt});
 
+    case (cache,_,_,_,_,SCode.ALG_CONTINUE( info = info),source,_,_,_,_)
+      equation
+        source = DAEUtil.addElementSourceFileInfo(source, info);
+        stmt = DAE.STMT_CONTINUE(source);
+      then
+        (cache,{stmt});
+
     // return
     case (cache,_,_,_,ClassInf.FUNCTION(path=_),SCode.ALG_RETURN( info = info),source,_,_,_,_)
       equation
diff --git a/Compiler/FrontEnd/InstUtil.mo b/Compiler/FrontEnd/InstUtil.mo
@@ -8934,6 +8934,7 @@ algorithm
       then ((false,false,unbound));
     case (DAE.STMT_BREAK(source=_),_,(_,_,unbound)) then ((true,false,unbound));
     case (DAE.STMT_RETURN(source=_),_,(_,_,unbound)) then ((true,true,unbound));
+    case (DAE.STMT_CONTINUE(source=_),_,(_,_,unbound)) then ((false,false,unbound));
     case (DAE.STMT_ARRAY_INIT(name=_),_,_) then inUnbound;
     case (DAE.STMT_FAILURE(body=stmts),_,(_,_,unbound))
       equation
diff --git a/Compiler/FrontEnd/SCode.mo b/Compiler/FrontEnd/SCode.mo
@@ -421,6 +421,11 @@ public uniontype Statement "The Statement type describes one algorithm statement
     Absyn.Info info;
   end ALG_TRY;
 
+  record ALG_CONTINUE
+    Comment comment;
+    Absyn.Info info;
+  end ALG_CONTINUE;
+
 end Statement;
 
 // common prefixes to elements
@@ -2083,6 +2088,9 @@ algorithm
     case ALG_BREAK(_,info)
     then Absyn.ALGORITHMITEM(Absyn.ALG_BREAK(),NONE(),info);
 
+    case ALG_CONTINUE(_,info)
+    then Absyn.ALGORITHMITEM(Absyn.ALG_CONTINUE(),NONE(),info);
+
     case ALG_FAILURE(body,_,info)
       equation
         algs1 = List.map(body,statementToAlgorithmItem);
@@ -3105,6 +3113,7 @@ algorithm
     case ALG_BREAK(info = info) then info;
     case ALG_FAILURE(info = info) then info;
     case ALG_TRY(info = info) then info;
+    case ALG_CONTINUE(info = info) then info;
     else
       equation
         Error.addInternalError("SCode.getStatementInfo failed");
diff --git a/Compiler/FrontEnd/SCodeUtil.mo b/Compiler/FrontEnd/SCodeUtil.mo
@@ -909,6 +909,9 @@ algorithm
         stmts2 = translateClassdefAlgorithmitems(elseBody);
       then SCode.ALG_TRY(stmts1,stmts2,comment,info);
 
+    case (Absyn.ALG_CONTINUE(),_,_)
+    then SCode.ALG_CONTINUE(comment,info);
+
     /*
     case (_,comment,info)
       equation
diff --git a/Compiler/OpenModelicaBootstrappingHeader.h b/Compiler/OpenModelicaBootstrappingHeader.h
@@ -2168,6 +2168,22 @@ extern struct record_description Absyn_Algorithm_ALG__TRY__desc;
 #define Absyn__ALG_5fTRY_3dBOX2 13
 #define Absyn__ALG_5fTRY(body,elseBody) (mmc_mk_box3(13,&Absyn_Algorithm_ALG__TRY__desc,body,elseBody))
 #ifdef ADD_METARECORD_DEFINITIONS
+#ifndef Absyn_Algorithm_ALG__CONTINUE__desc_added
+#define Absyn_Algorithm_ALG__CONTINUE__desc_added
+ADD_METARECORD_DEFINITIONS const char* Absyn_Algorithm_ALG__CONTINUE__desc__fields[1] = {"no fields"};
+ADD_METARECORD_DEFINITIONS struct record_description Absyn_Algorithm_ALG__CONTINUE__desc = {
+  "Absyn_Algorithm_ALG__CONTINUE",
+  "Absyn.Algorithm.ALG_CONTINUE",
+  Absyn_Algorithm_ALG__CONTINUE__desc__fields
+};
+#endif
+#else /* Only use the file as a header */
+extern struct record_description Absyn_Algorithm_ALG__CONTINUE__desc;
+#endif
+#define Absyn__ALG_5fCONTINUE_3dBOX0 14
+static const MMC_DEFSTRUCTLIT(Absyn__ALG_5fCONTINUE__struct,1,14) {&Absyn_Algorithm_ALG__CONTINUE__desc}};
+static void *Absyn__ALG_5fCONTINUE = MMC_REFSTRUCTLIT(Absyn__ALG_5fCONTINUE__struct);
+#ifdef ADD_METARECORD_DEFINITIONS
 #ifndef Absyn_Modification_CLASSMOD__desc_added
 #define Absyn_Modification_CLASSMOD__desc_added
 ADD_METARECORD_DEFINITIONS const char* Absyn_Modification_CLASSMOD__desc__fields[2] = {"elementArgLst","eqMod"};
diff --git a/Compiler/Template/AbsynDumpTV.mo b/Compiler/Template/AbsynDumpTV.mo
@@ -384,6 +384,8 @@ package Absyn
       list<AlgorithmItem> body;
       list<AlgorithmItem> elseBody;
     end ALG_TRY;
+
+    record ALG_CONTINUE end ALG_CONTINUE;
   end Algorithm;
 
   uniontype Modification
diff --git a/Compiler/Template/AbsynDumpTpl.mo b/Compiler/Template/AbsynDumpTpl.mo
@@ -4194,6 +4194,12 @@ algorithm
         txt = Tpl.writeTok(txt, Tpl.ST_STRING("end try;"));
       then txt;
 
+    case ( txt,
+           Absyn.ALG_CONTINUE() )
+      equation
+        txt = Tpl.writeTok(txt, Tpl.ST_STRING("continue"));
+      then txt;
+
     case ( txt,
            _ )
       then txt;
diff --git a/Compiler/Template/AbsynDumpTpl.tpl b/Compiler/Template/AbsynDumpTpl.tpl
@@ -664,6 +664,7 @@ match alg
       <%arg2%>
     end try;
     >>
+  case ALG_CONTINUE(__) then "continue"
 end dumpAlgorithm;
 
 template dumpAlgorithmBranch(Absyn.Exp cond, list<Absyn.AlgorithmItem> body,
diff --git a/Compiler/Template/CodegenC.tpl b/Compiler/Template/CodegenC.tpl
@@ -6950,6 +6950,7 @@ template algStatement(DAE.Statement stmt, Context context, Text &varDecls, Text
   case s as STMT_TERMINATE(__)      then algStmtTerminate(s, context, &varDecls, &auxFunction)
   case s as STMT_WHEN(__)           then algStmtWhen(s, context, &varDecls, &auxFunction)
   case s as STMT_BREAK(__)          then 'break;<%\n%>'
+  case s as STMT_CONTINUE(__)       then 'continue;<%\n%>'
   case s as STMT_FAILURE(__)        then algStmtFailure(s, context, &varDecls, &auxFunction)
   case s as STMT_RETURN(__)         then 'goto _return;<%\n%>'
   case s as STMT_NORETCALL(__)      then algStmtNoretcall(s, context, &varDecls, &auxFunction)
diff --git a/Compiler/Template/DAEDumpTV.mo b/Compiler/Template/DAEDumpTV.mo
@@ -500,18 +500,19 @@ package DAE
 
     record STMT_RETURN
       ElementSource source;
-      ElementSource source;
     end STMT_RETURN;
 
-    record STMT_BREAK
+    record STMT_CONTINUE
       ElementSource source;
+    end STMT_CONTINUE;
+
+    record STMT_BREAK
       ElementSource source;
     end STMT_BREAK;
 
     record STMT_FAILURE
       list<Statement> body;
       ElementSource source;
-      ElementSource source;
     end STMT_FAILURE;
   end Statement;
 
diff --git a/Compiler/Template/DAEDumpTpl.tpl b/Compiler/Template/DAEDumpTpl.tpl
@@ -806,6 +806,7 @@ match stmt
   case STMT_NORETCALL(__) then dumpNoRetCall(exp, source)
   case STMT_RETURN(__) then 'return;'
   case STMT_BREAK(__) then 'break;'
+  case STMT_CONTINUE(__) then 'continue;'
   case STMT_FAILURE(__) then 'fail();'
   else errorMsg("DAEDump.dumpStatement: Unknown statement.")
 
diff --git a/Compiler/Template/SCodeDumpTpl.tpl b/Compiler/Template/SCodeDumpTpl.tpl
@@ -437,6 +437,9 @@ match statement
     let cmt_str = dumpComment(comment, options)
     'failure(<%dumpStatement(stmt,options)%>)<%cmt_str%>;'
   case SCode.ALG_TRY(__) then dumpTryStatement(statement, options)
+  case ALG_CONTINUE(__) then
+    let cmt_str = dumpComment(comment, options)
+    'continue<%cmt_str%>;'
   else errorMsg("SCodeDump.dumpStatement: Unknown statement.")
 end dumpStatement;
 
diff --git a/Compiler/Template/SCodeTV.mo b/Compiler/Template/SCodeTV.mo
@@ -626,6 +626,11 @@ package SCode
       Absyn.Info info;
     end ALG_TRY;
 
+    record ALG_CONTINUE
+      Comment comment;
+      Absyn.Info info;
+    end ALG_CONTINUE;
+
   end Statement;
 
   uniontype Visibility
diff --git a/Compiler/Template/SimCodeTV.mo b/Compiler/Template/SimCodeTV.mo
@@ -1599,6 +1599,9 @@ package DAE
     record STMT_BREAK
       ElementSource source;
     end STMT_BREAK;
+    record STMT_CONTINUE
+      ElementSource source;
+    end STMT_CONTINUE;
     record STMT_FAILURE
       list<Statement> body;
       ElementSource source;
diff --git a/Parser/BaseModelica_Lexer.g b/Parser/BaseModelica_Lexer.g
@@ -48,6 +48,7 @@ CLASS;
 CONNECT;
 CONNECTOR;
 CONSTANT;
+CONTINUE;
 DISCRETE;
 DER;
 DEFINEUNIT;
diff --git a/Parser/MetaModelica_Lexer.g b/Parser/MetaModelica_Lexer.g
@@ -47,6 +47,7 @@ import BaseModelica_Lexer;
 /* MetaModelica extensions */
 AS : 'as';
 CASE : 'case';
+CONTINUE : 'continue';
 EQUALITY : 'equality';
 FAILURE : 'failure';
 GUARD : 'guard';
diff --git a/Parser/Modelica.g b/Parser/Modelica.g
@@ -817,6 +817,7 @@ constraint returns [void* ast]
   | a=when_clause_a
   | BREAK { a = Absyn__ALG_5fBREAK; }
   | RETURN { a = Absyn__ALG_5fRETURN; }
+  | CONTINUE { a = Absyn__ALG_5fCONTINUE; }
   | FAILURE LPAR al=algorithm RPAR { a = Absyn__ALG_5fFAILURE(mk_cons(al.ast,mk_nil())); }
   | EQUALITY LPAR e1=expression[metamodelica_enabled()] ASSIGN e2=expression[metamodelica_enabled()] RPAR
     {
@@ -841,6 +842,7 @@ algorithm returns [void* ast]
   | a=when_clause_a
   | BREAK { a = Absyn__ALG_5fBREAK; }
   | RETURN { a = Absyn__ALG_5fRETURN; }
+  | CONTINUE { a = Absyn__ALG_5fCONTINUE; }
   | FAILURE LPAR al=algorithm RPAR { a = Absyn__ALG_5fFAILURE(mk_cons(al.ast,mk_nil())); }
   | EQUALITY LPAR e1=expression[metamodelica_enabled()] ASSIGN e2=expression[metamodelica_enabled()] RPAR
     {
