beremiz: comparison plcopen/plcopen.py

equal deleted inserted replaced

-:13ee5f4ab612
+:42ea51d083ce
 index = text.find(block_type.upper(), index + len(block_type))
 return False
 setattr(cls, "hasblock", hasblock)
 def Search(self, criteria, parent_infos):
-return [(tuple(parent_infos),) + result for result in TestTextElement(self.gettext(), criteria)]
+return [(tuple(parent_infos),) + result for result in TestTextElement(self.getanyText(), criteria)]
 setattr(cls, "Search", Search)
 cls = PLCOpenParser.GetElementClass("project")
 if cls:
 cls.EnumeratedDataTypeValues = {}
 pou_name = pou.getname()
 pou_type = pou.getpouType()
 block_infos = {"name" : pou_name, "type" : pou_type, "extensible" : False,
 "inputs" : [], "outputs" : [], "comment" : pou.getdescription(),
 "generate" : generate_block, "initialise" : initialise_block}
-if pou.getinterface():
+if pou.interface is not None:
 return_type = pou.interface.getreturnType()
-if return_type:
+if return_type is not None:
 var_type = return_type.getcontent()
 var_type_name = var_type.getLocalTag()
 if var_type_name == "derived":
 block_infos["outputs"].append(("OUT", var_type.getname(), "none"))
 elif var_type_name in ["string", "wstring"]:
 self.AddElementUsingTreeInstance(name, type_content)
 # Analyze each pou
 for pou in self.getpous():
 name = pou.getname()
-if pou.interface:
+if pou.interface is not None:
 # Extract variables from every varLists
 for varlist_type, varlist in pou.getvars():
 for var in varlist.getvariable():
 vartype_content = var.gettype().getcontent()
 if vartype_content.getLocalTag() == "derived":
 globalvars.append(PLCOpenParser.CreateElement("varList"))
 var = PLCOpenParser.CreateElement("variable", "varListPlain")
 var.setname(name)
 var_type_obj = PLCOpenParser.CreateElement("dataType")
 if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:
-if var_type == "STRING":
+var_type_obj.setcontent(PLCOpenParser.CreateElement(
-var_type_obj.setcontent(PLCOpenParser.CreateElement("string", "elementaryTypes"))
+var_type.lower() if var_type in ["STRING", "WSTRING"]
-elif var_type == "WSTRING":
+else vartype, "dataType"))
-var_type_obj.setcontent(PLCOpenParser.CreateElement("wstring", "elementaryTypes"))
-else:
-var_type_obj.setcontent(PLCOpenParser.CreateElement(var_type))
 else:
-derived_type = PLCOpenParser.CreateElement("derived", "derivedTypes")
+derived_type = PLCOpenParser.CreateElement("derived", "dataType")
 derived_type.setname(var_type)
 var_type_obj.setcontent(derived_type)
 var.settype(var_type_obj)
 if location != "":
 var.setaddress(location)
 if description != "":
 ft = PLCOpenParser.CreateElementClass("formattedText")
-ft.settext(description)
+ft.setanyText(description)
 var.setdocumentation(ft)
 globalvars[-1].appendvariable(var)
 setattr(cls, "addglobalVar", addglobalVar)
 def updateElementName(self, old_name, new_name):
 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("array", "derivedTypes")
+cls = PLCOpenParser.GetElementClass("array", "dataType")
 if cls:
 setattr(cls, "updateElementName", _updateBaseTypeElementName)
 def Search(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))
 return search_result
-cls = PLCOpenParser.GetElementClass("subrangeSigned", "derivedTypes")
+cls = PLCOpenParser.GetElementClass("subrangeSigned", "dataType")
 if cls:
 setattr(cls, "updateElementName", _updateBaseTypeElementName)
 setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "derivedTypes")
+cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "dataType")
 if cls:
 setattr(cls, "updateElementName", _updateBaseTypeElementName)
 setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenParser.GetElementClass("enum", "derivedTypes")
+cls = PLCOpenParser.GetElementClass("enum", "dataType")
 if cls:
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
 def setdescription(self, description):
 doc = self.getdocumentation()
 if doc is None:
 doc = PLCOpenParser.CreateElement("formattedText")
 self.setdocumentation(doc)
-doc.settext(description)
+doc.setanyText(description)
 setattr(cls, "setdescription", setdescription)
 def getdescription(self):
 doc = self.getdocumentation()
 if doc is not None:
-return doc.gettext()
+return doc.getanyText()
 return ""
 setattr(cls, "getdescription", getdescription)
 def setbodyType(self, body_type):
 if len(self.body) > 0:
 def setvars(self, vars):
 if self.interface is None:
 self.interface = PLCOpenParser.CreateElement("interface", "pou")
 self.interface.setcontent(vars)
+print self.interface.tostring()
 setattr(cls, "setvars", setvars)
 def addpouLocalVar(self, var_type, name, location="", description=""):
 self.addpouVar(var_type, name, location=location, description=description)
 setattr(cls, "addpouLocalVar", addpouLocalVar)
 self.appendcontent(PLCOpenParser.CreateElementClass(var_class, "interface"))
 var = PLCOpenParser.CreateElementClass("variable", "varListPlain")
 var.setname(name)
 var_type_obj = PLCOpenParser.CreateElement("dataType")
 if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:
-if var_type == "STRING":
+var_type_obj.setcontent(PLCOpenParser.CreateElement(
-var_type_obj.setcontent(PLCOpenParser.CreateElement("string", "elementaryTypes"))
+var_type.lower() if var_type in ["STRING", "WSTRING"]
-elif var_type == "WSTRING":
+else var_type, "dataType"))
-var_type_obj.setcontent(PLCOpenParser.CreateElement("wstring", "elementaryTypes"))
-else:
-var_type_obj.setcontent(PLCOpenParser.CreateElement(var_type))
 else:
-derived_type = PLCOpenParser.CreateElement("derived", "derivedTypes")
+derived_type = PLCOpenParser.CreateElement("derived", "dataType")
 derived_type.setname(var_type)
 var_type_obj.setcontent(derived_type)
 var.settype(var_type_obj)
 if location != "":
 var.setaddress(location)
 if description != "":
 ft = PLCOpenParser.GetElementClass("formattedText")()
-ft.settext(description)
+ft.setanyText(description)
 var.setdocumentation(ft)
 content[-1]["value"].appendvariable(var)
 setattr(cls, "addpouVar", addpouVar)
 self.transitions.settransition([])
 transition = PLCOpenParser.CreateElement("transition", "transitions")
 transition.setname(name)
 transition.setbodyType(body_type)
 if body_type == "ST":
-transition.settext(":= ;")
+transition.setanyText(":= ;")
 elif body_type == "IL":
-transition.settext("\tST\t%s"%name)
+transition.setanyText("\tST\t%s"%name)
 self.transitions.appendtransition(transition)
 setattr(cls, "addtransition", addtransition)
 def gettransition(self, name):
 if self.transitions:
 raise TypeError, _("%s body don't have instances!")%self.content["name"]
 setattr(cls, "getcontentInstance", getcontentInstance)
 def getcontentRandomInstance(self, exclude):
 if self.content.getLocalTag() in ["LD","FBD","SFC"]:
-instance = self.content.xpath("*[regexp:test(@localId,'(%s)')]" % "|".join(map(str, exclude)))
+instance = self.content.xpath("*%s[position()=1]" %
+("[not(%s)]" % " or ".join(
+map(lambda x: "@localId=%d" % x, exclude))
+if len(exclude) > 0 else ""))
 if len(instance) > 0:
 return instance[0]
 return None
 else:
 raise TypeError, _("%s body don't have instances!")%self.content["name"]
 raise TypeError, "%s body don't have instances!"%self.content["name"]
 setattr(cls, "removecontentInstance", removecontentInstance)
 def settext(self, text):
 if self.content.getLocalTag() in ["IL","ST"]:
-self.content.settext(text)
+self.content.setanyText(text)
 else:
 raise TypeError, _("%s body don't have text!")%self.content["name"]
 setattr(cls, "settext", settext)
 def gettext(self):
 if self.content.getLocalTag() in ["IL","ST"]:
-return self.content.gettext()
+return self.content.getanyText()
 else:
 raise TypeError, _("%s body don't have text!")%self.content["name"]
 setattr(cls, "gettext", gettext)
 def hasblock(self, block_type):
 def _getvariableinfosFunction(type, input, output):
 def getvariableinfos(self):
 infos = _getelementinfos(self)
 infos["type"] = type
 specific_values = infos["specific_values"]
-specific_values["name"] = self.getexpression()
+specific_values["name"] = self.getexpression().text
 _getexecutionOrder(self, specific_values)
 if input and output:
 infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True, "input"))
 infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut, False, "output"))
 elif input:
 infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut, False, "default"))
 return infos
 return getvariableinfos
 def _getconnectorinfosFunction(type):
-def getvariableinfos(self):
+def getconnectorinfos(self):
 infos = _getelementinfos(self)
 infos["type"] = type
 infos["specific_values"]["name"] = self.getname()
 if type == "connector":
 infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True))
 elif type == "continuation":
 infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))
 return infos
-return getvariableinfos
+return getconnectorinfos
 def _getpowerrailinfosFunction(type):
 def getpowerrailinfos(self):
 infos = _getelementinfos(self)
 infos["type"] = type
 infos["specific_values"]["content"] = self.getcontentText()
 return infos
 setattr(cls, "getinfos", getinfos)
 def setcontentText(self, text):
-self.content.settext(text)
+self.content.setanyText(text)
 setattr(cls, "setcontentText", setcontentText)
 def getcontentText(self):
-return self.content.gettext()
+return self.content.getanyText()
 setattr(cls, "getcontentText", getcontentText)
 def updateElementName(self, old_name, new_name):
 self.content.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 condition = PLCOpenParser.CreateElement("reference", "condition")
 condition.setname(value)
 elif condition_type == "inline":
 condition = PLCOpenParser.CreateElement("inline", "condition")
 condition.setcontent(PLCOpenParser.GetElementClass("ST", "inline"))
-condition.settext(value)
+condition.setanyText(value)
 elif condition_type == "connection":
 condition = PLCOpenParser.CreateElementClass("connectionPointIn")
 self.condition.setcontent(condition)
 setattr(cls, "setconditionContent", setconditionContent)
 content = self.condition.getcontent()
 values = {"type" : content.getLocalTag()}
 if values["type"] == "reference":
 values["value"] = content.getname()
 elif values["type"] == "inline":
-values["value"] = content.gettext()
+values["value"] = content.getanyText()
 elif values["type"] == "connectionPointIn":
 values["type"] = "connection"
 values["value"] = content
 return values
 return ""
 elif content_name == "inline":
 search_result.extend(content.Search(criteria, parent_infos + ["inline"]))
 return search_result
 setattr(cls, "Search", Search)
-cls = _initElementClass("selectionDivergence", "sfcObjects_selectionDivergence", "single")
+cls = _initElementClass("selectionDivergence", "sfcObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getdivergenceinfosFunction(True, False))
-cls = _initElementClass("selectionConvergence", "sfcObjects_selectionConvergence", "multiple")
+cls = _initElementClass("selectionConvergence", "sfcObjects", "multiple")
 if cls:
 setattr(cls, "getinfos", _getdivergenceinfosFunction(False, False))
-cls = _initElementClass("simultaneousDivergence", "sfcObjects_simultaneousDivergence", "single")
+cls = _initElementClass("simultaneousDivergence", "sfcObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getdivergenceinfosFunction(True, True))
-cls = _initElementClass("simultaneousConvergence", "sfcObjects_simultaneousConvergence", "multiple")
+cls = _initElementClass("simultaneousConvergence", "sfcObjects", "multiple")
 if cls:
 setattr(cls, "getinfos", _getdivergenceinfosFunction(False, True))
-cls = _initElementClass("jumpStep", "sfcObjects_jumpStep", "single")
+cls = _initElementClass("jumpStep", "sfcObjects", "single")
 if cls:
 def getinfos(self):
 infos = _getelementinfos(self)
 infos["type"] = "jump"
 infos["specific_values"]["target"] = self.gettargetName()
 setattr(cls, "getreferenceName", getreferenceName)
 def setinlineContent(self, content):
 if self.inline:
 self.inline.setcontent(PLCOpenParser.CreateElementClass("ST", "action"))
-self.inline.settext(content)
+self.inline.setanyText(content)
 setattr(cls, "setinlineContent", setinlineContent)
 def getinlineContent(self):
 if self.inline:
-return self.inline.gettext()
+return self.inline.getanyText()
 return None
 setattr(cls, "getinlineContent", getinlineContent)
 def updateElementName(self, old_name, new_name):
 if self.reference and self.reference.getname() == old_name:
 ("duration", self.getduration()),
 ("indicator", self.getindicator())],
 criteria, parent_infos)
 setattr(cls, "Search", Search)
-cls = _initElementClass("actionBlock", "commonObjects_actionBlock", "single")
+cls = _initElementClass("actionBlock", "commonObjects", "single")
 if cls:
 def compatibility(self, tree):
 for child in tree.childNodes[:]:
 if child.nodeName == "connectionPointOut":
 tree.childNodes.remove(child)
 setattr(cls, "Search", Search)
 def _SearchInIOVariable(self, criteria, parent_infos=[]):
 return _Search([("expression", self.getexpression())], criteria, parent_infos + ["io_variable", self.getlocalId()])
-cls = _initElementClass("inVariable", "fbdObjects_inVariable")
+cls = _initElementClass("inVariable", "fbdObjects")
 if cls:
 setattr(cls, "getinfos", _getvariableinfosFunction("input", False, True))
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 self.expression = update_address(self.expression, address_model, new_leading)
 setattr(cls, "updateElementAddress", updateElementAddress)
 setattr(cls, "Search", _SearchInIOVariable)
-cls = _initElementClass("outVariable", "fbdObjects_outVariable", "single")
+cls = _initElementClass("outVariable", "fbdObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getvariableinfosFunction("output", True, False))
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 self.expression = update_address(self.expression, address_model, new_leading)
 setattr(cls, "updateElementAddress", updateElementAddress)
 setattr(cls, "Search", _SearchInIOVariable)
-cls = _initElementClass("inOutVariable", "fbdObjects_inOutVariable", "single")
+cls = _initElementClass("inOutVariable", "fbdObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getvariableinfosFunction("inout", True, True))
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 def _SearchInConnector(self, criteria, parent_infos=[]):
 return _Search([("name", self.getname())], criteria, parent_infos + ["connector", self.getlocalId()])
-cls = _initElementClass("continuation", "commonObjects_continuation")
+cls = _initElementClass("continuation", "commonObjects")
 if cls:
 setattr(cls, "getinfos", _getconnectorinfosFunction("continuation"))
 setattr(cls, "Search", _SearchInConnector)
 def updateElementName(self, old_name, new_name):
 if self.name == old_name:
 self.name = new_name
 setattr(cls, "updateElementName", updateElementName)
-cls = _initElementClass("connector", "commonObjects_connector", "single")
+cls = _initElementClass("connector", "commonObjects", "single")
 if cls:
 setattr(cls, "getinfos", _getconnectorinfosFunction("connector"))
 setattr(cls, "Search", _SearchInConnector)
 def updateElementName(self, old_name, new_name):
 self.relPosition.setx(x)
 self.relPosition.sety(y)
 setattr(cls, "setrelPositionXY", setrelPositionXY)
 def getrelPositionXY(self):
-if self.relPosition:
+if self.relPosition is not None:
 return self.relPosition.getx(), self.relPosition.gety()
-else:
+return self.relPosition
-return self.relPosition
 setattr(cls, "getrelPositionXY", getrelPositionXY)
 def addconnection(self):
 self.appendcontent(PLCOpenParser.CreateElement("connection"))
 setattr(cls, "addconnection", addconnection)
 def removeconnections(self):
 self.content = None
 setattr(cls, "removeconnections", removeconnections)
 def getconnections(self):
-return self.content
+return self.xpath("ppx:connection", namespaces=PLCOpenParser.NSMAP)
 setattr(cls, "getconnections", getconnections)
 def setconnectionId(self, idx, local_id):
 if len(self.content) > idx:
 self.content[idx].setrefLocalId(local_id)
 self.relPosition.setx(x)
 self.relPosition.sety(y)
 setattr(cls, "setrelPositionXY", setrelPositionXY)
 def getrelPositionXY(self):
-if self.relPosition:
+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:
 def setvalue(self, value):
 value = value.strip()
 if value.startswith("[") and value.endswith("]"):
-self.content = PLCOpenParser.CreateElement("arrayValue", "value")
+content = PLCOpenParser.CreateElement("arrayValue", "value")
 elif value.startswith("(") and value.endswith(")"):
-self.content = PLCOpenParser.CreateElement("structValue", "value")
+content = PLCOpenParser.CreateElement("structValue", "value")
 else:
-self.content = PLCOpenParser.CreateElement("simpleValue", "value")
+content = PLCOpenParser.CreateElement("simpleValue", "value")
-self.content.setvalue(value)
+content.setvalue(value)
+self.setcontent(content)
 setattr(cls, "setvalue", setvalue)
 def getvalue(self):
 return self.content.getvalue()
 setattr(cls, "getvalue", getvalue)

changeset 1291	42ea51d083ce
parent 1290	13ee5f4ab612
child 1293	40117d02601b