diff --git a/Compiler/Builtin.mo b/Compiler/Builtin.mo index 44d10310534..ce6f8ede46e 100644 --- a/Compiler/Builtin.mo +++ b/Compiler/Builtin.mo @@ -1,9 +1,9 @@ /* * This file is part of OpenModelica. * - * Copyright (c) 1998-2008, Linköpings University, + * Copyright (c) 1998-2008, Link�pings University, * Department of Computer and Information Science, - * SE-58183 Linköping, Sweden. + * SE-58183 Link�ping, Sweden. * * All rights reserved. * @@ -14,7 +14,7 @@ * * The OpenModelica software and the Open Source Modelica * Consortium (OSMC) Public License (OSMC-PL) are obtained - * from Linköpings University, either from the above address, + * from Link�pings University, either from the above address, * from the URL: http://www.ida.liu.se/projects/OpenModelica * and in the OpenModelica distribution. * @@ -62,19 +62,19 @@ protected import Values; `Real\', `Integer\' etc. */ public constant SCode.Class rlType=SCode.CLASS("RealType",false,false,SCode.R_PREDEFINED_REAL(), - SCode.PARTS({},{},{},{},{},NONE)) " real type "; + SCode.PARTS({},{},{},{},{},{},NONE)) " real type "; public constant SCode.Class intType=SCode.CLASS("IntegerType",false,false,SCode.R_PREDEFINED_INT(), - SCode.PARTS({},{},{},{},{},NONE)); + SCode.PARTS({},{},{},{},{},{},NONE)); public constant SCode.Class strType=SCode.CLASS("StringType",false,false,SCode.R_PREDEFINED_STRING(), - SCode.PARTS({},{},{},{},{},NONE)); + SCode.PARTS({},{},{},{},{},{},NONE)); public constant SCode.Class boolType=SCode.CLASS("BooleanType",false,false,SCode.R_PREDEFINED_BOOL(), - SCode.PARTS({},{},{},{},{},NONE)); + SCode.PARTS({},{},{},{},{},{},NONE)); protected constant SCode.Class enumType=SCode.CLASS("EnumType",false,false,SCode.R_PREDEFINED_ENUM(), - SCode.PARTS({},{},{},{},{},NONE)); + SCode.PARTS({},{},{},{},{},{},NONE)); protected constant SCode.Element unit=SCode.COMPONENT("unit",Absyn.UNSPECIFIED(),true,false,false, SCode.ATTR({},false,false,SCode.RW(),SCode.PARAM(),Absyn.BIDIR()),Absyn.TPATH(Absyn.IDENT("StringType"),NONE), @@ -141,25 +141,25 @@ protected constant list stateSelectComps={ SCode.ATTR({},false,false,SCode.RO(),SCode.CONST(),Absyn.BIDIR()),Absyn.TPATH(Absyn.IDENT("EnumType"),NONE),SCode.NOMOD(),NONE,NONE,NONE,NONE,NONE)} "The StateSelect enumeration" ; protected constant SCode.Class stateSelectType=SCode.CLASS("StateSelect",false,false,SCode.R_ENUMERATION(), - SCode.PARTS(stateSelectComps,{},{},{},{},NONE)) "The State Select Type" ; + SCode.PARTS(stateSelectComps,{},{},{},{},{},NONE)) "The State Select Type" ; public constant SCode.Class ExternalObjectType=SCode.CLASS("ExternalObject",false,false,SCode.R_CLASS(), SCode.PARTS( - {},{},{},{},{},NONE)) "ExternalObject type" ; + {},{},{},{},{},{},NONE)) "ExternalObject type" ; public constant SCode.Class realType=SCode.CLASS("Real",false,false,SCode.R_PREDEFINED_REAL(), SCode.PARTS( {unit,quantity,displayUnit,min,max,realStart,fixed,nominal, - stateSelect},{},{},{},{},NONE)) "- The `Real\' type" ; + stateSelect},{},{},{},{},{},NONE)) "- The `Real\' type" ; protected constant SCode.Class integerType=SCode.CLASS("Integer",false,false,SCode.R_PREDEFINED_INT(), - SCode.PARTS({quantity,min,max,integerStart,fixed},{},{},{},{},NONE)) "- The `Integer\' type" ; + SCode.PARTS({quantity,min,max,integerStart,fixed},{},{},{},{},{},NONE)) "- The `Integer\' type" ; protected constant SCode.Class stringType=SCode.CLASS("String",false,false,SCode.R_PREDEFINED_STRING(), - SCode.PARTS({quantity,stringStart},{},{},{},{},NONE)) "- The `String\' type" ; + SCode.PARTS({quantity,stringStart},{},{},{},{},{},NONE)) "- The `String\' type" ; protected constant SCode.Class booleanType=SCode.CLASS("Boolean",false,false,SCode.R_PREDEFINED_BOOL(), - SCode.PARTS({quantity,booleanStart,fixed},{},{},{},{},NONE)) "- The `Boolean\' type" ; + SCode.PARTS({quantity,booleanStart,fixed},{},{},{},{},{},NONE)) "- The `Boolean\' type" ; protected constant Types.Var timeVar=Types.VAR("time", Types.ATTR(false,false,SCode.RO(),SCode.VAR(),Absyn.BIDIR(),Absyn.UNSPECIFIED()),false,(Types.T_REAL({}),NONE),Types.UNBOUND()) "- The `time\' variable" ; diff --git a/Compiler/Ceval.mo b/Compiler/Ceval.mo index a3206937ac1..0428f4a1410 100644 --- a/Compiler/Ceval.mo +++ b/Compiler/Ceval.mo @@ -1,9 +1,9 @@ /* * This file is part of OpenModelica. * - * Copyright (c) 1998-2008, Linköpings University, + * Copyright (c) 1998-2008, Link�pings University, * Department of Computer and Information Science, - * SE-58183 Linköping, Sweden. + * SE-58183 Link�ping, Sweden. * * All rights reserved. * @@ -14,7 +14,7 @@ * * The OpenModelica software and the Open Source Modelica * Consortium (OSMC) Public License (OSMC-PL) are obtained - * from Linköpings University, either from the above address, + * from Link�pings University, either from the above address, * from the URL: http://www.ida.liu.se/projects/OpenModelica * and in the OpenModelica distribution. * @@ -1264,7 +1264,7 @@ protected function cevalKnownExternalFuncs "function: cevalKnownExternalFuncs list args; algorithm (outCache,cdef,env_1) := Lookup.lookupClass(inCache,env, funcpath, false); - SCode.CLASS(fid,_,_,SCode.R_EXT_FUNCTION(),SCode.PARTS(_,_,_,_,_,extdecl)) := cdef; + SCode.CLASS(fid,_,_,SCode.R_EXT_FUNCTION(),SCode.PARTS(_,_,_,_,_,_,extdecl)) := cdef; SOME(Absyn.EXTERNALDECL(id,lan,out,args,_)) := extdecl; isKnownExternalFunc(fid, id); res := cevalKnownExternalFuncs2(fid, id, vals, msg); diff --git a/Compiler/Cevalfunc.mo b/Compiler/Cevalfunc.mo index ee4245d1c83..7cc0179ae6c 100644 --- a/Compiler/Cevalfunc.mo +++ b/Compiler/Cevalfunc.mo @@ -55,7 +55,7 @@ algorithm Absyn.Path funcpath; list crefArgs; String str; - case(env,(callExp as Exp.CALL(path = funcpath,expLst = crefArgs)),inArgs, sc as SCode.CLASS(_,false,_,SCode.R_FUNCTION(),SCode.PARTS(elementList,_,_,_,_,_) ),daeList) + case(env,(callExp as Exp.CALL(path = funcpath,expLst = crefArgs)),inArgs, sc as SCode.CLASS(_,false,_,SCode.R_FUNCTION(),SCode.PARTS(elementList,_,_,_,_,_,_) ),daeList) equation str = Absyn.pathString(funcpath); str = Util.stringAppendList({"cevalfunc_",str}); @@ -66,7 +66,7 @@ algorithm retVal = convertOutputVarValues(retVals); then retVal; - case(env,(callExp as Exp.CALL(path = funcpath,expLst = crefArgs)),inArgs, sc as SCode.CLASS(_,false,_,SCode.R_FUNCTION(),SCode.PARTS(elementList,_,_,_,_,_) ),daeList) + case(env,(callExp as Exp.CALL(path = funcpath,expLst = crefArgs)),inArgs, sc as SCode.CLASS(_,false,_,SCode.R_FUNCTION(),SCode.PARTS(elementList,_,_,_,_,_,_) ),daeList) equation _ = extendEnvWithInputArgs(env,elementList,inArgs,crefArgs); str = Absyn.pathString(funcpath); @@ -74,7 +74,7 @@ algorithm Debug.fprint("failtrace", str); then fail(); - case(env,(callExp as Exp.CALL(path = funcpath,expLst = crefArgs)),inArgs, sc as SCode.CLASS(_,false,_,SCode.R_FUNCTION(),SCode.PARTS(elementList,_,_,_,_,_) ),daeList) + case(env,(callExp as Exp.CALL(path = funcpath,expLst = crefArgs)),inArgs, sc as SCode.CLASS(_,false,_,SCode.R_FUNCTION(),SCode.PARTS(elementList,_,_,_,_,_,_) ),daeList) equation failure(_ = extendEnvWithInputArgs(env,elementList,inArgs,crefArgs)); str = Absyn.pathString(funcpath); @@ -345,7 +345,7 @@ algorithm outVal := matchcontinue(env,sc) list eqs1,eqs2; list algs1,algs2; Env.Env env1; - case(env, SCode.CLASS(_,false,_,SCode.R_FUNCTION(),SCode.PARTS(_,eqs1,eqs2,algs1,algs2,_)) ) + case(env, SCode.CLASS(_,false,_,SCode.R_FUNCTION(),SCode.PARTS(_,_,eqs1,eqs2,algs1,algs2,_)) ) equation env1 = evaluateAlgorithmsList(env,algs1); then diff --git a/Compiler/DFA.mo b/Compiler/DFA.mo index 6c262d9e64b..2f0c7b0f3bc 100644 --- a/Compiler/DFA.mo +++ b/Compiler/DFA.mo @@ -1,9 +1,9 @@ /* * This file is part of OpenModelica. * - * Copyright (c) 1998-2008, Linköpings University, + * Copyright (c) 1998-2008, Link�pings University, * Department of Computer and Information Science, - * SE-58183 Linköping, Sweden. + * SE-58183 Link�ping, Sweden. * * All rights reserved. * @@ -14,7 +14,7 @@ * * The OpenModelica software and the Open Source Modelica * Consortium (OSMC) Public License (OSMC-PL) are obtained - * from Linköpings University, either from the above address, + * from Link�pings University, either from the above address, * from the URL: http://www.ida.liu.se/projects/OpenModelica * and in the OpenModelica distribution. * @@ -952,13 +952,13 @@ algorithm list fNameList; list fTypes; list elemList; - case (SCode.CLASS(_,_,_,_,SCode.PARTS(elemList,_,_,_,_,_))) + case (SCode.CLASS(_,_,_,_,SCode.PARTS(elemList,_,_,_,_,_,_))) equation fNameList = Util.listMap(elemList,extractFieldName); fTypes = Util.listMap(elemList,extractFieldType); then (fNameList,fTypes); /* adrpo: handle also the case model extends X end X; */ - case (SCode.CLASS(_,_,_,_,SCode.CLASS_EXTENDS(_,_,elemList,_,_,_,_))) + case (SCode.CLASS(_,_,_,_,SCode.CLASS_EXTENDS(_,_,elemList,_,_,_,_,_))) equation fNameList = Util.listMap(elemList,extractFieldName); fTypes = Util.listMap(elemList,extractFieldType); diff --git a/Compiler/Inst.mo b/Compiler/Inst.mo index a5ca83a1f6d..ba8f0f1ecc8 100644 --- a/Compiler/Inst.mo +++ b/Compiler/Inst.mo @@ -1,9 +1,9 @@ /* * This file is part of OpenModelica. * - * Copyright (c) 1998-2008, Linköpings University, + * Copyright (c) 1998-2008, Link�pings University, * Department of Computer and Information Science, - * SE-58183 Linköping, Sweden. + * SE-58183 Link�ping, Sweden. * * All rights reserved. * @@ -14,7 +14,7 @@ * * The OpenModelica software and the Open Source Modelica * Consortium (OSMC) Public License (OSMC-PL) are obtained - * from Linköpings University, either from the above address, + * from Link�pings University, either from the above address, * from the URL: http://www.ida.liu.se/projects/OpenModelica * and in the OpenModelica distribution. * @@ -6540,7 +6540,7 @@ algorithm case (cache,_,_,_,cl as SCode.CLASS(name = "String"),_,_) then (cache,{},cl); case (cache,_,_,_,cl as SCode.CLASS(name = "Boolean"),_,_) then (cache,{},cl); - case (cache,_,_,_,cl as SCode.CLASS(restriction = SCode.R_RECORD(), classDef = SCode.PARTS(_,_,_,_,_,_)),_,_) then (cache,{},cl); + case (cache,_,_,_,cl as SCode.CLASS(restriction = SCode.R_RECORD(), classDef = SCode.PARTS(_,_,_,_,_,_,_)),_,_) then (cache,{},cl); /*------------------------*/ /* MetaModelica extension */ @@ -6611,7 +6611,7 @@ algorithm /* extended classes type Y = Real[3]; class X extends Y; */ case (cache,env,mods,pre,SCode.CLASS(name = id,restriction = _, - classDef = SCode.PARTS(els,{},{},{},{},_)), + classDef = SCode.PARTS(els,{},{},{},{},{},_)), dims,impl) local list els, extendsels; SCode.Path path; equation @@ -7808,7 +7808,7 @@ algorithm equation typePath = Absyn.crefToPath(cr); /* make sure is an enumeration! */ - (_, SCode.CLASS(_, _, _, SCode.R_ENUMERATION(), SCode.PARTS(elementLst, {}, {}, {}, {}, NONE())), _) = + (_, SCode.CLASS(_, _, _, SCode.R_ENUMERATION(), SCode.PARTS(elementLst, {}, {}, {}, {}, {}, NONE())), _) = Lookup.lookupClass(cache, env, typePath, false); i = listLength(elementLst); (cache,l) = elabArraydimDecl(cache,env, cref, ds, impl, st,doVect); @@ -8382,7 +8382,7 @@ algorithm case (cache,env,ih,SCode.CLASS(name = id,partialPrefix = p,encapsulatedPrefix = e,restriction = r, classDef = SCode.PARTS(elementLst = elts,externalDecl=extDecl))) equation - stripped_class = SCode.CLASS(id,p,e,r,SCode.PARTS(elts,{},{},{},{},extDecl)); + stripped_class = SCode.CLASS(id,p,e,r,SCode.PARTS(elts,{},{},{},{},{},extDecl)); (cache,env_1,ih,_) = implicitFunctionInstantiation(cache,env,ih, Types.NOMOD(), Prefix.NOPRE(), Connect.emptySet, stripped_class, {}); then (cache,env_1,ih); @@ -8996,7 +8996,7 @@ protected function instEnumeration list comp; algorithm comp := makeEnumComponents(l); - outClass := SCode.CLASS(n,false,false,SCode.R_ENUMERATION(),SCode.PARTS(comp,{},{},{},{},NONE)); + outClass := SCode.CLASS(n,false,false,SCode.R_ENUMERATION(),SCode.PARTS(comp,{},{},{},{},{},NONE)); end instEnumeration; @@ -9837,7 +9837,7 @@ algorithm typePath = Absyn.crefToPath(cr); /* make sure is an enumeration! */ - (_, SCode.CLASS(_, _, _, SCode.R_ENUMERATION(), SCode.PARTS(elementLst, {}, {}, {}, {}, NONE())), _) = + (_, SCode.CLASS(_, _, _, SCode.R_ENUMERATION(), SCode.PARTS(elementLst, {}, {}, {}, {}, {}, NONE())), _) = Lookup.lookupClass(cache, env, typePath, false); len = listLength(elementLst); env_1 = addForLoopScope(env, i, (Types.T_INTEGER({}),NONE())) "//Debug.fprintln (\"insti\", \"for expression elaborated\") &" ; diff --git a/Compiler/Lookup.mo b/Compiler/Lookup.mo index 8d7afdcbba0..0f5238cb56e 100644 --- a/Compiler/Lookup.mo +++ b/Compiler/Lookup.mo @@ -1,9 +1,9 @@ /* * This file is part of OpenModelica. * - * Copyright (c) 1998-2008, Linköpings University, + * Copyright (c) 1998-2008, Link�pings University, * Department of Computer and Information Science, - * SE-58183 Linköping, Sweden. + * SE-58183 Link�ping, Sweden. * * All rights reserved. * @@ -14,7 +14,7 @@ * * The OpenModelica software and the Open Source Modelica * Consortium (OSMC) Public License (OSMC-PL) are obtained - * from Linköpings University, either from the above address, + * from Link�pings University, either from the above address, * from the URL: http://www.ida.liu.se/projects/OpenModelica * and in the OpenModelica distribution. * @@ -1799,7 +1799,7 @@ algorithm initStmts = {SCode.ALGORITHM(initAbsynStmts,NONE())}; then SCode.CLASS(id,false,false,SCode.R_FUNCTION(), - SCode.PARTS((reselt :: funcelts),{},{},initStmts,{},NONE)); + SCode.PARTS((reselt :: funcelts),{},{},{},initStmts,{},NONE)); case (cl,env) equation print("buildRecordConstructorClass failed\n"); then fail(); diff --git a/Compiler/SCode.mo b/Compiler/SCode.mo index 3287bee334f..459364dc2af 100644 --- a/Compiler/SCode.mo +++ b/Compiler/SCode.mo @@ -1,9 +1,9 @@ /* * This file is part of OpenModelica. * - * Copyright (c) 1998-2008, Linköpings University, + * Copyright (c) 1998-2008, Link�pings University, * Department of Computer and Information Science, - * SE-58183 Linköping, Sweden. + * SE-58183 Link�ping, Sweden. * * All rights reserved. * @@ -14,7 +14,7 @@ * * The OpenModelica software and the Open Source Modelica * Consortium (OSMC) Public License (OSMC-PL) are obtained - * from Linköpings University, either from the above address, + * from Link�pings University, either from the above address, * from the URL: http://www.ida.liu.se/projects/OpenModelica * and in the OpenModelica distribution. * @@ -158,6 +158,7 @@ uniontype ClassDef end A;" record PARTS "a class made of parts" list elementLst "the list of elements"; + list annotationLst "the list of annotations"; list normalEquationLst "the list of equations"; list initialEquationLst "the list of initial equations"; list normalAlgorithmLst "the list of algorithms"; @@ -183,6 +184,7 @@ uniontype ClassDef Ident baseClassName "the name of the base class we have to extend"; Mod modifications "the modifications that need to be applied to the base class"; list elementLst "the list of elements"; + list annotationLst "the list of annotations"; list normalEquationLst "the list of equations"; list initialEquationLst "the list of initial equations"; list normalAlgorithmLst "the list of algorithms"; @@ -196,6 +198,16 @@ uniontype ClassDef end ClassDef; +// stefan +public +uniontype Annotation + + record ANNOTATION + Mod modification; + end ANNOTATION; + +end Annotation; + public uniontype Equation "- Equations" record EQUATION "an equation" @@ -550,6 +562,7 @@ algorithm Option cmt; Option cmtString; list els; + list anns; list eqs,initeqs; list als,initals; Option decl; @@ -570,6 +583,7 @@ algorithm Debug.fprintln("elab", "elaborating class parts"); //debug_print("elaborating-parts:", Dump.unparseClassPartStrLst(1, parts, true)); els = elabClassdefElements(parts); + anns = elabClassdefAnnotations(parts); eqs = elabClassdefEquations(parts); initeqs = elabClassdefInitialequations(parts); als = elabClassdefAlgorithms(parts); @@ -577,7 +591,7 @@ algorithm decl = elabClassdefExternaldecls(parts); decl = elabAlternativeExternalAnnotation(decl,parts); then - PARTS(els,eqs,initeqs,als,initals,decl); + PARTS(els,anns,eqs,initeqs,als,initals,decl); case (Absyn.ENUMERATION(enumLiterals = Absyn.ENUMLITERALS(enumLiterals = lst))) equation Debug.fprintln("elab", "elaborating enumerations"); @@ -598,13 +612,14 @@ algorithm equation Debug.fprintln("elab", "elaborating model extends " +& name +& " ... end " +& name +& ";"); els = elabClassdefElements(parts); + anns = elabClassdefAnnotations(parts); eqs = elabClassdefEquations(parts); initeqs = elabClassdefInitialequations(parts); als = elabClassdefAlgorithms(parts); initals = elabClassdefInitialalgorithms(parts); mod = buildMod(SOME(Absyn.CLASSMOD(cmod,NONE)), false, Absyn.NON_EACH()); then - CLASS_EXTENDS(name,mod,els,eqs,initeqs,als,initals); + CLASS_EXTENDS(name,mod,els,anns,eqs,initeqs,als,initals); case (Absyn.PDER(functionName = path,vars = vars)) equation Debug.fprintln("elab", "elaborating pder( " +& Absyn.pathString(path) +& ", vars)"); @@ -719,6 +734,41 @@ algorithm end matchcontinue; end elabClassdefElements; +// stefan +protected function elabClassdefAnnotations +"function: elabClassdefAnnotations + turns a list of Absyn.ClassPart into a list of Annotations" + input list inClassPartList; + output list outAnnotationList; +algorithm + outAnnotationList := matchcontinue(inClassPartList) + local + list anns,anns1,anns2; + list eilst; + list cdr; + case({}) then {}; + case(Absyn.PUBLIC(eilst) :: cdr) + equation + anns = elabAnnotations(eilst); + anns1 = elabClassdefAnnotations(cdr); + anns2 = listAppend(anns,anns1); + then + anns2; + case(Absyn.PROTECTED(eilst) :: cdr) + equation + anns = elabAnnotations(eilst); + anns1 = elabClassdefAnnotations(cdr); + anns2 = listAppend(anns,anns1); + then + anns2; + case(_ :: cdr) + equation + anns = elabClassdefAnnotations(cdr); + then + anns; + end matchcontinue; +end elabClassdefAnnotations; + protected function elabClassdefEquations "function: elabClassdefEquations Convert an Absyn.ClassPart list to an Equation list." @@ -909,7 +959,62 @@ algorithm l; end matchcontinue; end elabEitemlist; - + +// stefan +protected function elabAnnotations +"function: elabAnnotations + turns a list of Absyn.ElementItem into a list of Annotations" + input list inElementItemList; + output list outAnnotationList; +algorithm + outAnnotationList := matchcontinue(inElementItemList) + local + list cdr; + Absyn.Annotation ann; + Annotation res; + list anns,anns_1; + case({}) then {}; + case(Absyn.ANNOTATIONITEM(ann) :: cdr) + equation + res = elabAnnotation(ann); + anns = elabAnnotations(cdr); + anns_1 = res :: anns; + then + anns_1; + case(_ :: cdr) + equation + anns = elabAnnotations(cdr); + then + anns; + case(_) + equation + Debug.fprintln("failtrace","SCode.elabAnnotations failed"); + then + fail(); + end matchcontinue; +end elabAnnotations; + +// stefan +protected function elabAnnotation +"function: elabAnnotation + translates an Absyn.Annotation into an SCode.Annotation" + input Absyn.Annotation inAnnotation; + output Annotation outAnnotation; +algorithm + outAnnotation := matchcontinue(inAnnotation) + local + list args; + Annotation res; + Mod m; + case(Absyn.ANNOTATION(args)) + equation + m = buildMod(SOME(Absyn.CLASSMOD(args,NONE)), false, Absyn.NON_EACH()); + res = ANNOTATION(m); + then + res; + end matchcontinue; +end elabAnnotation; + public function elabElement "function: elabElement This function converts an Absyn.Element to a list of SCode.Element. @@ -2320,6 +2425,27 @@ public function elementEqual end matchcontinue; end elementEqual; +// stefan +public function annotationEqual +"function: annotationEqual + returns true if 2 annotations are equal" + input Annotation annotation1; + input Annotation annotation2; + output Boolean equal; +algorithm + equal := matchcontinue(annotation1,annotation2) + local + Mod mod1,mod2; + Boolean res; + case(ANNOTATION(mod1),ANNOTATION(mod2)) + equation + res = modEqual(mod1,mod2); + then + res; + case(_,_) then false; + end matchcontinue; +end annotationEqual; + protected function classEqual "function classEqual returns true if two classes are equal" @@ -2381,25 +2507,27 @@ protected function classDefEqual equal := matchcontinue(cdef1,cdef2) local list elts1,elts2; + list anns1,anns2; list eqns1,eqns2; list ieqns1,ieqns2; list algs1,algs2; list ialgs1,ialgs2; - list blst1,blst2,blst3,blst4,blst5,blst; + list blst1,blst2,blst3,blst4,blst5,blst6,blst; Absyn.ElementAttributes attr1,attr2; Absyn.TypeSpec tySpec1, tySpec2; Mod mod1,mod2; Boolean b1,b2,b3; list ilst1,ilst2; list blst; - case(PARTS(elts1,eqns1,ieqns1,algs1,ialgs1,_),PARTS(elts2,eqns2,ieqns2,algs2,ialgs2,_)) + case(PARTS(elts1,anns1,eqns1,ieqns1,algs1,ialgs1,_),PARTS(elts2,anns2,eqns2,ieqns2,algs2,ialgs2,_)) equation blst1 = Util.listThreadMap(elts1,elts2,elementEqual); blst2 = Util.listThreadMap(eqns1,eqns2,equationEqual); blst3 = Util.listThreadMap(ieqns1,ieqns2,equationEqual); blst4 = Util.listThreadMap(algs1,algs2,algorithmEqual); blst5 = Util.listThreadMap(ialgs1,ialgs2,algorithmEqual); - blst = Util.listFlatten({blst1,blst2,blst3,blst4,blst5}); + blst6 = Util.listThreadMap(anns1,anns2,annotationEqual); + blst = Util.listFlatten({blst1,blst2,blst3,blst4,blst5,blst6}); equal = Util.boolAndList(blst); then equal; case (DERIVED(tySpec1,mod1,attr1),DERIVED(tySpec2,mod2,attr2)) @@ -2414,11 +2542,11 @@ protected function classDefEqual blst = Util.listThreadMap(ilst1,ilst2,stringEqual); equal = Util.boolAndList(blst); then equal; - case (cdef1 as CLASS_EXTENDS(_,_,_,_,_,_,_),cdef2 as CLASS_EXTENDS(_,_,_,_,_,_,_)) + case (cdef1 as CLASS_EXTENDS(_,_,_,_,_,_,_,_),cdef2 as CLASS_EXTENDS(_,_,_,_,_,_,_,_)) equation equality(cdef1=cdef2); then true; - case (cdef1 as CLASS_EXTENDS(_,_,_,_,_,_,_),cdef2 as CLASS_EXTENDS(_,_,_,_,_,_,_)) + case (cdef1 as CLASS_EXTENDS(_,_,_,_,_,_,_,_),cdef2 as CLASS_EXTENDS(_,_,_,_,_,_,_,_)) equation failure(equality(cdef1=cdef2)); then true; diff --git a/Compiler/omc_debug/Makefile.in b/Compiler/omc_debug/Makefile.in index c702f43b29f..fc1004701bf 100644 --- a/Compiler/omc_debug/Makefile.in +++ b/Compiler/omc_debug/Makefile.in @@ -107,7 +107,7 @@ clean: $(RM) -f $(SRCO) $(SRCC) $(SRCH) $(PROG)$(EXEXT) *~ $(ALLMO:.mo=.srz) $(ALLMO:.mo=.sig) reallyclean: clean - $(RM) -f $(ALLMO) $(ALLMO:.mo=.sig) $(PROG)$(EXEEXT) $(ALLMO:.mo=.srz) + $(RM) -f $(ALLMO) $(ALLMO:.mo=.sig) $(ALLMO:.mo=.sigx) $(PROG)$(EXEEXT) $(ALLMO:.mo=.srz) # don't remove these files after intermediate build steps .PRECIOUS: Makefile $(ALLMO) diff --git a/Compiler/omc_release/Makefile.in b/Compiler/omc_release/Makefile.in index 209a3bd03d5..1f067dc8597 100644 --- a/Compiler/omc_release/Makefile.in +++ b/Compiler/omc_release/Makefile.in @@ -107,7 +107,7 @@ clean: $(RM) -f $(SRCO) $(SRCC) $(SRCH) $(PROG)$(EXEEXT) *~ $(ALLMO:.mo=.srz) reallyclean: clean - $(RM) -f $(ALLMO) $(ALLMO:.mo=.sig) $(ALLMO:.mo=.srz) $(PROG)$(EXEEXT) + $(RM) -f $(ALLMO) $(ALLMO:.mo=.sig) $(ALLMO:.mo=.sigx) $(ALLMO:.mo=.srz) $(PROG)$(EXEEXT) # don't remove these files after intermediate build steps .PRECIOUS: Makefile $(ALLMO)