Deleted flag +synchronousFeatures and replaced it by checking for flag +std=3.3 or greater

bernhard-thiele · bernhard-thiele · commit 950f8783b340 · 2014-07-16T17:24:35.000Z
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@21539 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
diff --git a/Compiler/FrontEnd/Ceval.mo b/Compiler/FrontEnd/Ceval.mo
@@ -1153,7 +1153,7 @@ algorithm
     // BTH
     case "Clock"
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then cevalBuiltinClock;
     // MetaModelica type conversions
     case "intString" equation true = Config.acceptMetaModelicaGrammar(); then cevalIntString;
diff --git a/Compiler/FrontEnd/ClassInf.mo b/Compiler/FrontEnd/ClassInf.mo
@@ -432,9 +432,9 @@ algorithm
     case (SCode.R_PREDEFINED_STRING(),p) then TYPE_STRING(p);
     case (SCode.R_PREDEFINED_BOOLEAN(),p) then TYPE_BOOL(p);
     // BTH
-    case (SCode.R_PREDEFINED_CLOCK(),p)
+    case (SCode.R_PREDEFINED_CLOCK(),p) 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);   
       then TYPE_CLOCK(p);
     case (SCode.R_PREDEFINED_ENUMERATION(),p) then TYPE_ENUM(p);
      /* Meta Modelica extensions */
diff --git a/Compiler/FrontEnd/Inst.mo b/Compiler/FrontEnd/Inst.mo
@@ -1297,9 +1297,9 @@ algorithm
     case "String" then DAE.T_STRING_DEFAULT;
     case "Boolean" then DAE.T_BOOL_DEFAULT;
     // BTH
-    case "Clock"
+    case "Clock" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);  
       then DAE.T_CLOCK_DEFAULT;
   end match;
 end getBasicTypeType;
@@ -1314,9 +1314,9 @@ algorithm
     case "String" then getStringAttributeType;
     case "Boolean" then getBoolAttributeType;
     // BTH
-    case "Clock"
+    case "Clock" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then getClockAttributeType;
   end match;
 end getBasicTypeAttrTyper;
@@ -1883,10 +1883,10 @@ algorithm
         System.setPartialInstantiation(partialInst);
       then (cache,env,ih,ci_state,{});
 
-    // BTH
+    // BTH 
     case (cache,env,ih,_,_,ci_state,(SCode.CLASS(name = "Clock")),_,_,_,_)
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
         System.setPartialInstantiation(partialInst);
       then (cache,env,ih,ci_state,{});
 
diff --git a/Compiler/FrontEnd/InstUtil.mo b/Compiler/FrontEnd/InstUtil.mo
@@ -609,7 +609,7 @@ public function prefixEqualUnlessBasicType
   input SCode.Element cls;
 algorithm
   _ := matchcontinue (pre1, pre2, cls)
-    local
+    local      
     // adrpo: TODO! FIXME!, I think here we should have pre1 = Prefix.CLASSPRE(variability1) == pre2 = Prefix.CLASSPRE(variability2)
 
     // don't care about prefix for:
@@ -634,7 +634,7 @@ algorithm
     // BTH
     case (_, _, SCode.CLASS(name = "Clock"))
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);   
       then ();
 
     // anything else, check for equality!
@@ -656,7 +656,7 @@ algorithm
     case("String") then true;
     case("Boolean") then true;
     // BTH
-    case("Clock") then Util.if_(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true, false);
+    case("Clock") then Util.if_(intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33), true, false);
     else false;
   end match;
 end isBuiltInClass;
@@ -859,11 +859,11 @@ algorithm
         true = listMember(r, {SCode.R_TYPE(), SCode.R_CONNECTOR(false), SCode.R_CONNECTOR(true)});
         true = listMember(id, {"Real", "Integer", "Boolean", "String"});
       then ();
-
+        
     //BTH same as above but extended with Clock type if Flags.SYNCHRONOUS_FEATURES == true
     case (_, _, _, r, {SCode.EXTENDS(baseClassPath=Absyn.IDENT(id))})
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
         true = listMember(r, {SCode.R_TYPE(), SCode.R_CONNECTOR(false), SCode.R_CONNECTOR(true)});
         true = listMember(id, {"Real", "Integer", "Boolean", "String", "Clock"});
       then ();
@@ -902,16 +902,16 @@ protected
   list<SCode.Restriction> rstLst;
 algorithm
   // BTH add Clock type to both lists if Flags.SYNCHRONOUS_FEATURES == true
-  strLst := Util.if_(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES),
+  strLst := Util.if_(intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33),
       {"Real", "Integer", "String", "Boolean", "Clock"},
       {"Real", "Integer", "String", "Boolean"});
   b1 := listMember(childName, strLst);
-
-  rstLst := Util.if_(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES),
+  
+  rstLst := Util.if_(intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33),
       {SCode.R_TYPE(), SCode.R_PREDEFINED_INTEGER(), SCode.R_PREDEFINED_REAL(), SCode.R_PREDEFINED_STRING(), SCode.R_PREDEFINED_BOOLEAN(), SCode.R_PREDEFINED_CLOCK()},
       {SCode.R_TYPE(), SCode.R_PREDEFINED_INTEGER(), SCode.R_PREDEFINED_REAL(), SCode.R_PREDEFINED_STRING(), SCode.R_PREDEFINED_BOOLEAN()});
   b2 := listMember(childRestriction, rstLst);
-
+                   
   b3 := valueEq(parentRestriction, SCode.R_TYPE());
 
   //b2 := listMember(childRestriction, {SCode.R_TYPE(), SCode.R_ENUMERATION(), SCode.R_PREDEFINED_INTEGER(), SCode.R_PREDEFINED_REAL(), SCode.R_PREDEFINED_STRING(), SCode.R_PREDEFINED_BOOLEAN(), SCode.R_PREDEFINED_ENUMERATION()});
@@ -3776,9 +3776,9 @@ algorithm
     case (cache, _, _, _, cl as SCode.CLASS(name = "String"), _, _) then (cache,{},cl,DAE.NOMOD());
     case (cache, _, _, _, cl as SCode.CLASS(name = "Boolean"), _, _) then (cache,{},cl,DAE.NOMOD());
     // BTH
-    case (cache, _, _, _, cl as SCode.CLASS(name = "Clock"), _, _)
+    case (cache, _, _, _, cl as SCode.CLASS(name = "Clock"), _, _) 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then (cache,{},cl,DAE.NOMOD());
 
     case (cache, _, _, _, cl as SCode.CLASS(restriction = SCode.R_RECORD(_),
@@ -8321,16 +8321,16 @@ algorithm
     // you cannot redeclare a basic type, only the properties and the binding, i.e.
     // redeclare constant Boolean standardOrderComponents = true
     case (DAE.REDECL(_, _, {(SCode.COMPONENT(typeSpec=Absyn.TPATH(path=path)), _)})) equation
-      true = Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES);
-
+      true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
+      
       name = Absyn.pathFirstIdent(path);
       // BTH
       true = listMember(name, {"Real", "Integer", "Boolean", "String", "Clock"});
     then true;
-
+    
     case (DAE.REDECL(_, _, {(SCode.COMPONENT(typeSpec=Absyn.TPATH(path=path)), _)})) equation
-      false = Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES);
-
+      false = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
+      
       name = Absyn.pathFirstIdent(path);
       // BTH
       true = listMember(name, {"Real", "Integer", "Boolean", "String"});
diff --git a/Compiler/FrontEnd/MetaUtil.mo b/Compiler/FrontEnd/MetaUtil.mo
@@ -370,9 +370,9 @@ algorithm
     case(Absyn.IDENT("String")) then DAE.T_STRING_DEFAULT;
     case(Absyn.IDENT("Boolean")) then DAE.T_BOOL_DEFAULT;
     // BTH
-    case(Absyn.IDENT("Clock"))
+    case(Absyn.IDENT("Clock")) 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);   
       then DAE.T_CLOCK_DEFAULT;
   end match;
 end reparseType;
diff --git a/Compiler/FrontEnd/NFInst.mo b/Compiler/FrontEnd/NFInst.mo
@@ -557,9 +557,9 @@ algorithm
     case ("String", _) then DAE.T_STRING(inAttributes, DAE.emptyTypeSource);
     case ("Boolean", _) then DAE.T_BOOL(inAttributes, DAE.emptyTypeSource);
     // BTH
-    case ("Clock", _)
+    case ("Clock", _) 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);   
       then DAE.T_CLOCK(inAttributes, DAE.emptyTypeSource);
     case ("StateSelect", _) then DAE.T_ENUMERATION_DEFAULT;
   end match;
diff --git a/Compiler/FrontEnd/NFSCodeLookup.mo b/Compiler/FrontEnd/NFSCodeLookup.mo
@@ -1279,7 +1279,7 @@ algorithm
     case "ExternalObject" then BUILTIN_EXTERNALOBJECT;
     case "Clock"
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then BUILTIN_CLOCK;
     case "$RealType" then BUILTIN_REALTYPE_ITEM;
     case "$IntegerType" then BUILTIN_INTEGERTYPE_ITEM;
diff --git a/Compiler/FrontEnd/Static.mo b/Compiler/FrontEnd/Static.mo
@@ -598,7 +598,7 @@ algorithm
     // BTH
     case (cache,_,Absyn.CLOCK(value = ck),_,st,_,_,_,_)
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33); 
       then
         (cache,DAE.CLKCONST(ck),DAE.PROP(DAE.T_CLOCK_DEFAULT,DAE.C_CONST()),st);
 
@@ -4619,7 +4619,7 @@ algorithm
 
         call = Expression.makePureBuiltinCall("Clock", {}, ty);
       then (cache, call, DAE.PROP(DAE.T_CLOCK_DEFAULT, DAE.C_CONST()));
-
+      
     // clock with Integer interval "Clock(intervalCounter)"
     case (cache,env,{aintervalCounter},{},impl,pre,_)
       equation
@@ -6889,37 +6889,37 @@ algorithm
     case "getInstanceName" then elabBuiltinGetInstanceName;
     case "classDirectory" then elabBuiltinClassDirectory;
     case "sample" then elabBuiltinSample;
-    case "Clock"
+    case "Clock" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then elabBuiltinClock;
-    case "previous"
+    case "previous" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then elabBuiltinPrevious;
-    case "hold"
+    case "hold" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then elabBuiltinHold;
-    case "subSample"
+    case "subSample" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then elabBuiltinSubSample;
-    case "superSample"
+    case "superSample" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then elabBuiltinSuperSample;
-    case "shiftSample"
+    case "shiftSample" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then elabBuiltinShiftSample;
-    case "backSample"
+    case "backSample" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then elabBuiltinBackSample;
-    case "noClock"
+    case "noClock" 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33);
       then elabBuiltinNoClock;
   end match;
 end elabBuiltinHandler;
diff --git a/Compiler/Script/Interactive.mo b/Compiler/Script/Interactive.mo
@@ -9602,9 +9602,9 @@ algorithm
     case (Absyn.IDENT(name = "Boolean"),_,_) then (Absyn.CLASS("Boolean",false,false,false,Absyn.R_PREDEFINED_BOOLEAN(),
           Absyn.dummyParts,Absyn.dummyInfo),Absyn.IDENT("Boolean"));
     // BTH
-    case (Absyn.IDENT(name = "Clock"),_,_)
+    case (Absyn.IDENT(name = "Clock"),_,_) 
       equation
-        true = boolEq(Flags.getConfigBool(Flags.SYNCHRONOUS_FEATURES), true);
+        true = intGe(Flags.getConfigEnum(Flags.LANGUAGE_STANDARD), 33); 
       then (Absyn.CLASS("Clock",false,false,false,Absyn.R_PREDEFINED_CLOCK(),
           Absyn.dummyParts,Absyn.dummyInfo),Absyn.IDENT("Clock"));
 
diff --git a/Compiler/Util/Flags.mo b/Compiler/Util/Flags.mo
@@ -899,10 +899,6 @@ constant ConfigFlag PROFILING_LEVEL = CONFIG_FLAG(58, "profiling",
     })),
   Util.gettext("Sets the profiling level to use. Profiled equations and functions record execution time and count for each time step taken by the integrator."));
 
-constant ConfigFlag SYNCHRONOUS_FEATURES = CONFIG_FLAG(59, "synchronousFeatures",
-  NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(),
-  Util.gettext("Activate support for the synchronous language elements of Modelica 3.3, Chapter 16."));
-
 // This is a list of all configuration flags. A flag can not be used unless it's
 // in this list, and the list is checked at initialization so that all flags are
 // sorted by index (and thus have unique indices).
@@ -964,8 +960,7 @@ constant list<ConfigFlag> allConfigFlags = {
   GENERATE_SYMBOLIC_JACOBIAN,
   GENERATE_SYMBOLIC_LINEARIZATION,
   INT_ENUM_CONVERSION,
-  PROFILING_LEVEL,
-  SYNCHRONOUS_FEATURES
+  PROFILING_LEVEL
 };
 
 public function new
