beremiz: comparison plcopen/plcopen.py

equal deleted inserted replaced

-:a2324624e516
+:cf5ef4c0deff
 xml_declaration=True,
 encoding='utf-8'))
 project_file.close()
-cls = PLCOpenParser.GetElementClass("formattedText")
+# ----------------------------------------------------------------------
-if cls:
+def _updateFormattedTextClass(cls):
 def updateElementName(self, old_name, new_name):
 text = self.getanyText()
 pattern = re.compile('\\b' + old_name + '\\b', re.IGNORECASE)
 text = pattern.sub(new_name, text)
 self.setanyText(text)
 def Search(self, criteria, parent_infos):
 return [(tuple(parent_infos),) + result for result in TestTextElement(self.getanyText(), criteria)]
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("project")
-if cls:
+cls = PLCOpenParser.GetElementClass("formattedText")
+if cls:
+_updateFormattedTextClass(cls)
+# ----------------------------------------------------------------------
+def _updateProjectClass(cls):
 def setname(self, name):
 self.contentHeader.setname(name)
 setattr(cls, "setname", setname)
 def getname(self):
 for configuration in self.instances.configurations.getconfiguration():
 result.extend(configuration.Search(criteria, parent_infos))
 return result
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("contentHeader", "project")
-if cls:
+cls = PLCOpenParser.GetElementClass("project")
+if cls:
+_updateProjectClass(cls)
+# ----------------------------------------------------------------------
+def _updateContentHeaderProjectClass(cls):
 def setpageSize(self, width, height):
 self.coordinateInfo.setpageSize(width, height)
 setattr(cls, "setpageSize", setpageSize)
 def getpageSize(self):
 scaling["LD"] = self.coordinateInfo.getscaling("LD")
 scaling["SFC"] = self.coordinateInfo.getscaling("SFC")
 return scaling
 setattr(cls, "getscaling", getscaling)
-cls = PLCOpenParser.GetElementClass("coordinateInfo", "contentHeader")
-if cls:
+cls = PLCOpenParser.GetElementClass("contentHeader", "project")
+if cls:
+_updateContentHeaderProjectClass(cls)
+# ----------------------------------------------------------------------
+def _updateCoordinateInfoContentHeaderClass(cls):
 def setpageSize(self, width, height):
 if width == 0 and height == 0:
 self.deletepageSize()
 else:
 if self.pageSize is None:
 return self.ld.scaling.getx(), self.ld.scaling.gety()
 elif language == "SFC":
 return self.sfc.scaling.getx(), self.sfc.scaling.gety()
 return 0, 0
 setattr(cls, "getscaling", getscaling)
+cls = PLCOpenParser.GetElementClass("coordinateInfo", "contentHeader")
+if cls:
+_updateCoordinateInfoContentHeaderClass(cls)
+# ----------------------------------------------------------------------
 def _Search(attributes, criteria, parent_infos):
 search_result = []
 for attr, value in attributes:
 search_result.extend(variable.Search(criteria, parent_infos + [variable_type, var_number]))
 var_number += 1
 return search_result
-cls = PLCOpenParser.GetElementClass("configuration", "configurations")
+# ----------------------------------------------------------------------
-if cls:
+def _updateConfigurationConfigurationsClass(cls):
 def addglobalVar(self, var_type, name, location="", description=""):
 globalvars = self.getglobalVars()
 if len(globalvars) == 0:
 globalvars.append(PLCOpenParser.CreateElement("varList"))
 var = PLCOpenParser.CreateElement("variable", "varListPlain")
 for resource in self.getresource():
 search_result.extend(resource.Search(criteria, parent_infos))
 return search_result
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("resource", "configuration")
-if cls:
+cls = PLCOpenParser.GetElementClass("configuration", "configurations")
+if cls:
+_updateConfigurationConfigurationsClass(cls)
+# ----------------------------------------------------------------------
+def _updateResourceConfigurationClass(cls):
 def updateElementName(self, old_name, new_name):
 _updateConfigurationResourceElementName(self, old_name, new_name)
 for instance in self.getpouInstance():
 instance.updateElementName(old_name, new_name)
 for task in self.gettask():
 search_result.extend(instance.Search(criteria, parent_infos + ["instance", instance_number]))
 instance_number += 1
 return search_result
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("task", "resource")
-if cls:
+cls = PLCOpenParser.GetElementClass("resource", "configuration")
+if cls:
+_updateResourceConfigurationClass(cls)
+# ----------------------------------------------------------------------
+def _updateTaskResourceClass(cls):
 def updateElementName(self, old_name, new_name):
 if TextMatched(self.single, old_name):
 self.single = new_name
 if TextMatched(self.interval, old_name):
 self.interval = new_name
 ("interval", self.getinterval()),
 ("priority", str(self.getpriority()))],
 criteria, parent_infos)
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("pouInstance")
-if cls:
+cls = PLCOpenParser.GetElementClass("task", "resource")
+if cls:
+_updateTaskResourceClass(cls)
+# ----------------------------------------------------------------------
+def _updatePouInstanceClass(cls):
 def updateElementName(self, old_name, new_name):
 if TextMatched(self.typeName, old_name):
 self.typeName = new_name
 setattr(cls, "updateElementName", updateElementName)
 return _Search([("name", self.getname()),
 ("type", self.gettypeName())],
 criteria, parent_infos)
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("variable", "varListPlain")
-if cls:
+cls = PLCOpenParser.GetElementClass("pouInstance")
+if cls:
+_updatePouInstanceClass(cls)
+# ----------------------------------------------------------------------
+def _updateVariableVarListPlain(cls):
 def gettypeAsText(self):
 vartype_content = self.gettype().getcontent()
 vartype_content_name = vartype_content.getLocalTag()
 # Variable type is a user data type
 if vartype_content_name == "derived":
 if doc is not None:
 search_result.extend(doc.Search(criteria, parent_infos + ["documentation"]))
 return search_result
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("types", "project")
-if cls:
+cls = PLCOpenParser.GetElementClass("variable", "varListPlain")
+if cls:
+_updateVariableVarListPlain(cls)
+# ----------------------------------------------------------------------
+def _updateTypesProjectClass(cls):
 def getdataTypeElements(self):
 return self.dataTypes.getdataType()
 setattr(cls, "getdataTypeElements", getdataTypeElements)
 def getdataTypeElement(self, name):
 search_result.extend(pou.Search(criteria, parent_infos))
 return search_result
 setattr(cls, "Search", Search)
+cls = PLCOpenParser.GetElementClass("types", "project")
+if cls:
+_updateTypesProjectClass(cls)
+# ----------------------------------------------------------------------
 def _updateBaseTypeElementName(self, old_name, new_name):
 self.baseType.updateElementName(old_name, new_name)
-cls = PLCOpenParser.GetElementClass("dataType", "dataTypes")
+def _updateDataTypeDataTypesClass(cls):
-if cls:
 setattr(cls, "updateElementName", _updateBaseTypeElementName)
 def Search(self, criteria, parent_infos=[]):
 search_result = []
 filter = criteria["filter"]
 if self.initialValue is not None:
 search_result.extend(_Search([("initial", self.initialValue.getvalue())], criteria, parent_infos))
 return search_result
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("dataType")
-if cls:
+cls = PLCOpenParser.GetElementClass("dataType", "dataTypes")
+if cls:
+_updateDataTypeDataTypesClass(cls)
+# ----------------------------------------------------------------------
+def _updateDataTypeClass(cls):
 def updateElementName(self, old_name, new_name):
 content_name = self.content.getLocalTag()
 if content_name in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]:
 self.content.updateElementName(old_name, new_name)
 elif content_name == "struct":
 content_name = content_name.upper()
 search_result.extend(_Search([("base", content_name)], criteria, parent_infos))
 return search_result
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("derived", "dataType")
-if cls:
+cls = PLCOpenParser.GetElementClass("dataType")
+if cls:
+_updateDataTypeClass(cls)
+# ----------------------------------------------------------------------
+def _updateDerivedDataTypeClass(cls):
 def updateElementName(self, old_name, new_name):
 if TextMatched(self.name, old_name):
 self.name = new_name
 setattr(cls, "updateElementName", updateElementName)
 def Search(self, criteria, parent_infos=[]):
 return [(tuple(parent_infos),) + result for result in TestTextElement(self.name, criteria)]
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("array", "dataType")
-if cls:
+cls = PLCOpenParser.GetElementClass("derived", "dataType")
+if cls:
+_updateDerivedDataTypeClass(cls)
+# ----------------------------------------------------------------------
+def _updateArrayDataTypeClass(cls):
 setattr(cls, "updateElementName", _updateBaseTypeElementName)
 def Search(self, criteria, parent_infos=[]):
 search_result = self.baseType.Search(criteria, parent_infos)
 for i, dimension in enumerate(self.getdimension()):
 criteria, parent_infos + ["range", i]))
 return search_result
 setattr(cls, "Search", Search)
+cls = PLCOpenParser.GetElementClass("array", "dataType")
+if cls:
+_updateArrayDataTypeClass(cls)
+# ----------------------------------------------------------------------
 def _SearchInSubrange(self, criteria, parent_infos=[]):
 search_result = self.baseType.Search(criteria, parent_infos)
 search_result.extend(_Search([("lower", self.range.getlower()),
 ("upper", self.range.getupper())],
 criteria, parent_infos))
 cls = PLCOpenParser.GetElementClass("subrangeSigned", "dataType")
 if cls:
 setattr(cls, "updateElementName", _updateBaseTypeElementName)
 setattr(cls, "Search", _SearchInSubrange)
+# ----------------------------------------------------------------------
 cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "dataType")
 if cls:
 setattr(cls, "updateElementName", _updateBaseTypeElementName)
 setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenParser.GetElementClass("enum", "dataType")
-if cls:
+# ----------------------------------------------------------------------
+def _updateEnumDataTypeClass(cls):
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
 enumerated_datatype_values_xpath = PLCOpen_XPath("ppx:values/ppx:value")
 search_result.append((tuple(parent_infos + ["value", i]),) + result)
 return search_result
 setattr(cls, "Search", Search)
+cls = PLCOpenParser.GetElementClass("enum", "dataType")
+if cls:
+_updateEnumDataTypeClass(cls)
+# ----------------------------------------------------------------------
 def _getvariableTypeinfos(variable_type):
 type_content = variable_type.getcontent()
 type_content_type = type_content.getLocalTag()
 if type_content_type == "derived":
 return type_content.getname()
 return type_content_type.upper()
-cls = PLCOpenParser.GetElementClass("pou", "pous")
+def _updatePouPousClass(cls):
-if cls:
-block_inputs_xpath = PLCOpen_XPath(
-"ppx:interface/*[self::ppx:inputVars or self::ppx:inOutVars]/ppx:variable")
-block_outputs_xpath = PLCOpen_XPath(
-"ppx:interface/*[self::ppx:outputVars or self::ppx:inOutVars]/ppx:variable")
 def getblockInfos(self):
 block_infos = {
 "name": self.getname(),
 "type": self.getpouType(),
 "extensible": False,
 search_result.extend(transition.Search(criteria, parent_infos))
 return search_result
 setattr(cls, "Search", Search)
+cls = PLCOpenParser.GetElementClass("pou", "pous")
+if cls:
+block_inputs_xpath = PLCOpen_XPath(
+"ppx:interface/*[self::ppx:inputVars or self::ppx:inOutVars]/ppx:variable")
+block_outputs_xpath = PLCOpen_XPath(
+"ppx:interface/*[self::ppx:outputVars or self::ppx:inOutVars]/ppx:variable")
+_updatePouPousClass(cls)
+# ----------------------------------------------------------------------
 def setbodyType(self, body_type):
 if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:
 self.body.setcontent(PLCOpenParser.CreateElement(body_type, "body"))
 else:
 raise ValueError("%s isn't a valid body type!" % type)
 def updateElementAddress(self, address_model, new_leading):
 self.body.updateElementAddress(address_model, new_leading)
-cls = PLCOpenParser.GetElementClass("transition", "transitions")
+# ----------------------------------------------------------------------
-if cls:
+def _updateTransitionTransitionsClass(cls):
 setattr(cls, "setbodyType", setbodyType)
 setattr(cls, "getbodyType", getbodyType)
 setattr(cls, "resetexecutionOrder", resetexecutionOrder)
 setattr(cls, "compileexecutionOrder", compileexecutionOrder)
 setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
 search_result.append((tuple(parent_infos + ["name"]),) + result)
 search_result.extend(self.body.Search(criteria, parent_infos))
 return search_result
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("action", "actions")
-if cls:
+cls = PLCOpenParser.GetElementClass("transition", "transitions")
+if cls:
+_updateTransitionTransitionsClass(cls)
+# ----------------------------------------------------------------------
+def _updateActionActionsClass(cls):
 setattr(cls, "setbodyType", setbodyType)
 setattr(cls, "getbodyType", getbodyType)
 setattr(cls, "resetexecutionOrder", resetexecutionOrder)
 setattr(cls, "compileexecutionOrder", compileexecutionOrder)
 setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
 search_result.append((tuple(parent_infos + ["name"]),) + result)
 search_result.extend(self.body.Search(criteria, parent_infos))
 return search_result
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("body")
-if cls:
+cls = PLCOpenParser.GetElementClass("action", "actions")
+if cls:
+_updateActionActionsClass(cls)
+# ----------------------------------------------------------------------
+def _updateBodyClass(cls):
 cls.currentExecutionOrderId = 0
 cls.checkedBlocksDict = {}
 def resetcurrentExecutionOrderId(self):
 object.__setattr__(self, "currentExecutionOrderId", 0)
 search_result.extend(element.Search(criteria, parent_infos))
 return search_result
 setattr(cls, "Search", Search)
+cls = PLCOpenParser.GetElementClass("body")
+if cls:
+_updateBodyClass(cls)
+# ----------------------------------------------------------------------
 def getx(self):
 return self.position.getx()
 def gety(self):
 setattr(cls, "updateConnectionsId", _connectionsFunctions["update"][connectionPointInType])
 setattr(cls, "Search", _SearchInElement)
 return cls
-cls = _initElementClass("comment", "commonObjects")
+# ----------------------------------------------------------------------
-if cls:
+def _updateCommentCommonObjectsClass(cls):
 def setcontentText(self, text):
 self.content.setanyText(text)
 setattr(cls, "setcontentText", setcontentText)
 def getcontentText(self):
 def Search(self, criteria, parent_infos=[]):
 return self.content.Search(criteria, parent_infos + ["comment", self.getlocalId(), "content"])
 setattr(cls, "Search", Search)
-cls = _initElementClass("block", "fbdObjects")
-if cls:
+cls = _initElementClass("comment", "commonObjects")
+if cls:
+_updateCommentCommonObjectsClass(cls)
+# ----------------------------------------------------------------------
+def _updateBlockFbdObjectsClass(cls):
 def getBoundingBox(self):
 bbox = _getBoundingBox(self)
 for input in self.inputVariables.getvariable():
 bbox.union(_getConnectionsBoundingBox(input.connectionPointIn))
 return bbox
 for result in TestTextElement(variable.getformalParameter(), criteria):
 search_result.append((tuple(parent_infos + ["output", i]),) + result)
 return search_result
 setattr(cls, "Search", Search)
+cls = _initElementClass("block", "fbdObjects")
+if cls:
+_updateBlockFbdObjectsClass(cls)
+# ----------------------------------------------------------------------
 _initElementClass("leftPowerRail", "ldObjects")
 _initElementClass("rightPowerRail", "ldObjects", "multiple")
 def _UpdateLDElementName(self, old_name, new_name):
 def SearchInLDElement(self, criteria, parent_infos=[]):
 return _Search([("reference", self.variable)], criteria, parent_infos + [ld_element_type, self.getlocalId()])
 return SearchInLDElement
+# ----------------------------------------------------------------------
 cls = _initElementClass("contact", "ldObjects", "single")
 if cls:
 setattr(cls, "updateElementName", _UpdateLDElementName)
 setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
 setattr(cls, "Search", _getSearchInLDElement("contact"))
+# ----------------------------------------------------------------------
 cls = _initElementClass("coil", "ldObjects", "single")
 if cls:
 setattr(cls, "updateElementName", _UpdateLDElementName)
 setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
 setattr(cls, "Search", _getSearchInLDElement("coil"))
-cls = _initElementClass("step", "sfcObjects", "single")
-if cls:
+# ----------------------------------------------------------------------
+def _updateStepSfcObjectSingleClass(cls):
 def Search(self, criteria, parent_infos=[]):
 return _Search([("name", self.getname())], criteria, parent_infos + ["step", self.getlocalId()])
 setattr(cls, "Search", Search)
-cls = _initElementClass("transition", "sfcObjects")
-if cls:
+cls = _initElementClass("step", "sfcObjects", "single")
+if cls:
+_updateStepSfcObjectSingleClass(cls)
+# ----------------------------------------------------------------------
+def _updateTransitionSfcObjectsClass(cls):
 def setconditionContent(self, condition_type, value):
 if self.condition is None:
 self.addcondition()
 if condition_type == "connection":
 condition = PLCOpenParser.CreateElement("connectionPointIn", "condition")
 elif content_name == "inline":
 search_result.extend(content.Search(criteria, parent_infos + ["inline"]))
 return search_result
 setattr(cls, "Search", Search)
+cls = _initElementClass("transition", "sfcObjects")
+if cls:
+_updateTransitionSfcObjectsClass(cls)
+# ----------------------------------------------------------------------
 _initElementClass("selectionDivergence", "sfcObjects", "single")
 _initElementClass("selectionConvergence", "sfcObjects", "multiple")
 _initElementClass("simultaneousDivergence", "sfcObjects", "single")
 _initElementClass("simultaneousConvergence", "sfcObjects", "multiple")
-cls = _initElementClass("jumpStep", "sfcObjects", "single")
-if cls:
+def _updateJumpStepSfcObjectSingleClass(cls):
 def Search(self, criteria, parent_infos):
 return _Search([("target", self.gettargetName())], criteria, parent_infos + ["jump", self.getlocalId()])
 setattr(cls, "Search", Search)
-cls = PLCOpenParser.GetElementClass("action", "actionBlock")
-if cls:
+cls = _initElementClass("jumpStep", "sfcObjects", "single")
+if cls:
+_updateJumpStepSfcObjectSingleClass(cls)
+# ----------------------------------------------------------------------
+def _updateActionActionBlockClass(cls):
 def setreferenceName(self, name):
 if self.reference is not None:
 self.reference.setname(name)
 setattr(cls, "setreferenceName", setreferenceName)
 ("duration", self.getduration()),
 ("indicator", self.getindicator())],
 criteria, parent_infos)
 setattr(cls, "Search", Search)
-cls = _initElementClass("actionBlock", "commonObjects", "single")
-if cls:
+cls = PLCOpenParser.GetElementClass("action", "actionBlock")
+if cls:
+_updateActionActionBlockClass(cls)
+# ----------------------------------------------------------------------
+def _updateActionBlockCommonObjectsSingleClass(cls):
 def setactions(self, actions):
 self.action = []
 for params in actions:
 action = PLCOpenParser.CreateElement("action", "actionBlock")
 self.appendaction(action)
 search_result.extend(action.Search(criteria, parent_infos + ["action", idx]))
 return search_result
 setattr(cls, "Search", Search)
+cls = _initElementClass("actionBlock", "commonObjects", "single")
+if cls:
+_updateActionBlockCommonObjectsSingleClass(cls)
+# ----------------------------------------------------------------------
 def _SearchInIOVariable(self, criteria, parent_infos=[]):
 return _Search([("expression", self.expression)], criteria, parent_infos + ["io_variable", self.getlocalId()])
 def _UpdateIOElementName(self, old_name, new_name):
 def _SearchInConnector(self, criteria, parent_infos=[]):
 return _Search([("name", self.getname())], criteria, parent_infos + ["connector", self.getlocalId()])
-cls = _initElementClass("continuation", "commonObjects")
+# ----------------------------------------------------------------------
-if cls:
+def _updateContinuationCommonObjectsClass(cls):
 setattr(cls, "Search", _SearchInConnector)
 def updateElementName(self, old_name, new_name):
 if TextMatched(self.name, old_name):
 self.name = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = _initElementClass("connector", "commonObjects", "single")
-if cls:
+cls = _initElementClass("continuation", "commonObjects")
+if cls:
+_updateContinuationCommonObjectsClass(cls)
+# ----------------------------------------------------------------------
+def _updateConnectorCommonObjectsSingleClass(cls):
 setattr(cls, "Search", _SearchInConnector)
 def updateElementName(self, old_name, new_name):
 if TextMatched(self.name, old_name):
 self.name = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenParser.GetElementClass("connection")
-if cls:
+cls = _initElementClass("connector", "commonObjects", "single")
+if cls:
+_updateConnectorCommonObjectsSingleClass(cls)
+# ----------------------------------------------------------------------
+def _updateConnectionClass(cls):
 def setpoints(self, points):
 positions = []
 for point in points:
 position = PLCOpenParser.CreateElement("position", "connection")
 position.setx(point.x)
 for position in self.position:
 points.append((position.getx(), position.gety()))
 return points
 setattr(cls, "getpoints", getpoints)
-cls = PLCOpenParser.GetElementClass("connectionPointIn")
-if cls:
+cls = PLCOpenParser.GetElementClass("connection")
+if cls:
+_updateConnectionClass(cls)
+# ----------------------------------------------------------------------
+def _updateConnectionPointInClass(cls):
 def setrelPositionXY(self, x, y):
 self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointIn")
 self.relPosition.setx(x)
 self.relPosition.sety(y)
 setattr(cls, "setrelPositionXY", setrelPositionXY)
 if connection is not None:
 return connection.getformalParameter()
 return None
 setattr(cls, "getconnectionParameter", getconnectionParameter)
 cls = PLCOpenParser.GetElementClass("connectionPointOut")
 if cls:
 def setrelPositionXY(self, x, y):
 self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointOut")
 self.relPosition.setx(x)
 if self.relPosition is not None:
 return self.relPosition.getx(), self.relPosition.gety()
 return self.relPosition
 setattr(cls, "getrelPositionXY", getrelPositionXY)
-cls = PLCOpenParser.GetElementClass("value")
-if cls:
+cls = PLCOpenParser.GetElementClass("connectionPointIn")
+if cls:
+_updateConnectionPointInClass(cls)
+# ----------------------------------------------------------------------
+def _updateValueClass(cls):
 def setvalue(self, value):
 value = value.strip()
 if value.startswith("[") and value.endswith("]"):
 content = PLCOpenParser.CreateElement("arrayValue", "value")
 elif value.startswith("(") and value.endswith(")"):
 setattr(cls, "setvalue", setvalue)
 def getvalue(self):
 return self.content.getvalue()
 setattr(cls, "getvalue", getvalue)
+cls = PLCOpenParser.GetElementClass("value")
+if cls:
+_updateValueClass(cls)
+# ----------------------------------------------------------------------
 def extractValues(values):
 items = values.split(",")
 i = 1
 else:
 raise ValueError(_("\"%s\" is an invalid value!") % value)
 return items
-cls = PLCOpenParser.GetElementClass("arrayValue", "value")
+def _updateArrayValueValueClass(cls):
-if cls:
-arrayValue_model = re.compile("([0-9]+)\((.*)\)$")
 def setvalue(self, value):
 elements = []
 for item in extractValues(value[1:-1]):
 item = item.strip()
 element = PLCOpenParser.CreateElement("value", "arrayValue")
 else:
 values.append(element.getvalue())
 return "[%s]" % ", ".join(values)
 setattr(cls, "getvalue", getvalue)
-cls = PLCOpenParser.GetElementClass("structValue", "value")
-if cls:
+cls = PLCOpenParser.GetElementClass("arrayValue", "value")
-structValue_model = re.compile("(.*):=(.*)")
+if cls:
+arrayValue_model = re.compile("([0-9]+)\((.*)\)$")
+_updateArrayValueValueClass(cls)
+# ----------------------------------------------------------------------
+def _updateStructValueValueClass(cls):
 def setvalue(self, value):
 elements = []
 for item in extractValues(value[1:-1]):
 result = structValue_model.match(item)
 if result is not None:
 values = []
 for element in self.value:
 values.append("%s := %s" % (element.getmember(), element.getvalue()))
 return "(%s)" % ", ".join(values)
 setattr(cls, "getvalue", getvalue)
+cls = PLCOpenParser.GetElementClass("structValue", "value")
+if cls:
+structValue_model = re.compile("(.*):=(.*)")
+_updateStructValueValueClass(cls)

changeset 1840	cf5ef4c0deff
parent 1837	c507c363625e
child 1846	14b40afccd69