beremiz: comparison plcopen/plcopen.py

equal deleted inserted replaced

-:c8e008b8cefe
+:72a826dfcfbb
 text = text[:result.start()] + new_address + text[result.end():]
 startpos = result.start() + len(new_address)
 result = address_model.search(self.text, startpos)
 self.text = text
 setattr(cls, "updateElementAddress", updateElementAddress)
+def hasblock(self, block_type):
+text = self.text.upper()
+index = text.find(block_type.upper())
+while index != -1:
+if (not (index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_")) and
+not (index < len(text) - len(block_type) and text[index + len(block_type)] != "(")):
+return True
+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)]
 setattr(cls, "Search", Search)
 block_infos["usage"] = "\n (%s) => (%s)" % (", ".join(["%s:%s" % (input[1], input[0]) for input in block_infos["inputs"]]),
 ", ".join(["%s:%s" % (output[1], output[0]) for output in block_infos["outputs"]]))
 self.CustomBlockTypes.append(block_infos)
 setattr(cls, "AddCustomBlockType", AddCustomBlockType)
+def AddElementUsingTreeInstance(self, name, type_infos):
+typename = type_infos.getname()
+if not self.ElementUsingTree.has_key(typename):
+self.ElementUsingTree[typename] = [name]
+elif name not in self.ElementUsingTree[typename]:
+self.ElementUsingTree[typename].append(name)
+setattr(cls, "AddElementUsingTreeInstance", AddElementUsingTreeInstance)
 def RefreshElementUsingTree(self):
 # Reset the tree of user-defined element cross-use
 self.ElementUsingTree = {}
 pous = self.getpous()
 datatypes = self.getdataTypes()
-# Reference all the user-defined elementu names and initialize the tree of
-# user-defined elemnt cross-use
-elementnames = [datatype.getname() for datatype in datatypes] + \
-[pou.getname() for pou in pous]
-for name in elementnames:
-self.ElementUsingTree[name] = []
 # Analyze each datatype
 for datatype in datatypes:
 name = datatype.getname()
 basetype_content = datatype.baseType.getcontent()
 if basetype_content["name"] == "derived":
 if name in self.ElementUsingTree[typename]:
 self.ElementUsingTree[typename].append(name)
 elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]:
 base_type = basetype_content["value"].baseType.getcontent()
 if base_type["name"] == "derived":
-typename = base_type["value"].getname()
+self.AddElementUsingTreeInstance(name, base_type["value"])
-if self.ElementUsingTree.has_key(typename) and name not in self.ElementUsingTree[typename]:
-self.ElementUsingTree[typename].append(name)
 elif basetype_content["name"] == "struct":
 for element in basetype_content["value"].getvariable():
 type_content = element.type.getcontent()
 if type_content["name"] == "derived":
-typename = type_content["value"].getname()
+self.AddElementUsingTreeInstance(name, type_content["value"])
-if self.ElementUsingTree.has_key(typename) and name not in self.ElementUsingTree[typename]:
-self.ElementUsingTree[typename].append(name)
 # Analyze each pou
 for pou in pous:
 name = pou.getname()
 if pou.interface:
 # Extract variables from every varLists
 for type, varlist in pou.getvars():
 for var in varlist.getvariable():
 vartype_content = var.gettype().getcontent()
 if vartype_content["name"] == "derived":
-typename = vartype_content["value"].getname()
+self.AddElementUsingTreeInstance(name, vartype_content["value"])
-if self.ElementUsingTree.has_key(typename) and name not in self.ElementUsingTree[typename]:
+for typename in self.ElementUsingTree.iterkeys():
-self.ElementUsingTree[typename].append(name)
+if typename != name and pou.hasblock(block_type=typename) and name not in self.ElementUsingTree[typename]:
+self.ElementUsingTree[typename].append(name)
 setattr(cls, "RefreshElementUsingTree", RefreshElementUsingTree)
 def GetParentType(self, type):
 if self.CustomTypeHierarchy.has_key(type):
 return self.CustomTypeHierarchy[type]
 var_number += 1
 return search_result
 cls = PLCOpenClasses.get("configurations_configuration", None)
 if cls:
+def addglobalVar(self, type, name, location="", description=""):
+globalvars = self.getglobalVars()
+if len(globalvars) == 0:
+globalvars.append(PLCOpenClasses["varList"]())
+var = PLCOpenClasses["varListPlain_variable"]()
+var.setname(name)
+var_type = PLCOpenClasses["dataType"]()
+if type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:
+if type == "STRING":
+var_type.setcontent({"name" : "string", "value" : PLCOpenClasses["elementaryTypes_string"]()})
+elif type == "WSTRING":
+var_type.setcontent({"name" : "wstring", "value" : PLCOpenClasses["elementaryTypes_wstring"]()})
+else:
+var_type.setcontent({"name" : type, "value" : None})
+else:
+derived_type = PLCOpenClasses["derivedTypes_derived"]()
+derived_type.setname(type)
+var_type.setcontent({"name" : "derived", "value" : derived_type})
+var.settype(var_type)
+if location != "":
+var.setaddress(location)
+if description != "":
+ft = PLCOpenClasses["formattedText"]()
+ft.settext(description)
+var.setdocumentation(ft)
+globalvars[-1].appendvariable(var)
+setattr(cls, "addglobalVar", addglobalVar)
 def updateElementName(self, old_name, new_name):
 _updateConfigurationResourceElementName(self, old_name, new_name)
 for resource in self.getresource():
 resource.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 if len(varlist["value"].getvariable()) == 0:
 content.remove(varlist)
 break
 setattr(cls, "removepouVar", removepouVar)
-def hasblock(self, name):
+def hasblock(self, name=None, block_type=None):
 if self.getbodyType() in ["FBD", "LD", "SFC"]:
 for instance in self.getinstances():
-if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name:
+if (isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and
+(name and instance.getinstanceName() == name or
+block_type and instance.gettypeName() == block_type)):
 return True
 if self.transitions:
 for transition in self.transitions.gettransition():
-result = transition.hasblock(name)
+result = transition.hasblock(name, block_type)
 if result:
 return result
 if self.actions:
 for action in self.actions.getaction():
-result = action.hasblock(name)
+result = action.hasblock(name, block_type)
 if result:
 return result
+elif block_type is not None and len(self.body) > 0:
+return self.body[0].hasblock(block_type)
 return False
 setattr(cls, "hasblock", hasblock)
 def addtransition(self, name, type):
 if not self.transitions:
 self.body.settext(text)
 def gettext(self):
 return self.body.gettext()
+def hasblock(self, name=None, block_type=None):
+if self.getbodyType() in ["FBD", "LD", "SFC"]:
+for instance in self.getinstances():
+if (isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and
+(name and instance.getinstanceName() == name or
+block_type and instance.gettypeName() == block_type)):
+return True
+elif block_type is not None:
+return self.body.hasblock(block_type)
+return False
+def updateElementName(self, old_name, new_name):
+self.body.updateElementName(old_name, new_name)
+def updateElementAddress(self, address_model, new_leading):
+self.body.updateElementAddress(address_model, new_leading)
 cls = PLCOpenClasses.get("transitions_transition", None)
 if cls:
 setattr(cls, "setbodyType", setbodyType)
 setattr(cls, "getbodyType", getbodyType)
 setattr(cls, "resetexecutionOrder", resetexecutionOrder)
 setattr(cls, "getrandomInstance", getrandomInstance)
 setattr(cls, "getinstanceByName", getinstanceByName)
 setattr(cls, "removeinstance", removeinstance)
 setattr(cls, "settext", settext)
 setattr(cls, "gettext", gettext)
+setattr(cls, "hasblock", hasblock)
-def updateElementName(self, old_name, new_name):
-self.body.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-def updateElementAddress(self, address_model, new_leading):
-self.body.updateElementAddress(address_model, new_leading)
 setattr(cls, "updateElementAddress", updateElementAddress)
-def hasblock(self, name):
-if self.getbodyType() in ["FBD", "LD", "SFC"]:
-for instance in self.getinstances():
-if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name:
-return True
-return False
-setattr(cls, "hasblock", hasblock)
 def Search(self, criteria, parent_infos):
 search_result = []
 parent_infos = parent_infos[:-1] + ["T::%s::%s" % (parent_infos[-1].split("::")[1], self.getname())]
 for result in TestTextElement(self.getname(), criteria):
 search_result.append((tuple(parent_infos + ["name"]),) + result)
 setattr(cls, "getrandomInstance", getrandomInstance)
 setattr(cls, "getinstanceByName", getinstanceByName)
 setattr(cls, "removeinstance", removeinstance)
 setattr(cls, "settext", settext)
 setattr(cls, "gettext", gettext)
+setattr(cls, "hasblock", hasblock)
-def updateElementName(self, old_name, new_name):
-self.body.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-def updateElementAddress(self, address_model, new_leading):
-self.body.updateElementAddress(address_model, new_leading)
 setattr(cls, "updateElementAddress", updateElementAddress)
-def hasblock(self, name):
-if self.getbodyType() in ["FBD", "LD", "SFC"]:
-for instance in self.getinstances():
-if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name:
-return True
-return False
-setattr(cls, "hasblock", hasblock)
 def Search(self, criteria, parent_infos):
 search_result = []
 parent_infos = parent_infos[:-1] + ["A::%s::%s" % (parent_infos[-1].split("::")[1], self.getname())]
 for result in TestTextElement(self.getname(), criteria):
 search_result.append((tuple(parent_infos + ["name"]),) + result)
 setattr(cls, "Search", Search)
 cls = PLCOpenClasses.get("body", None)
 if cls:
 cls.currentExecutionOrderId = 0
+cls.instances_dict = {}
+setattr(cls, "_init_", getattr(cls, "__init__"))
+def __init__(self, *args, **kwargs):
+self._init_(*args, **kwargs)
+self.instances_dict = {}
+setattr(cls, "__init__", __init__)
+setattr(cls, "_loadXMLTree", getattr(cls, "loadXMLTree"))
+def loadXMLTree(self, *args, **kwargs):
+self._loadXMLTree(*args, **kwargs)
+if self.content["name"] in ["LD","FBD","SFC"]:
+self.instances_dict = dict(
+[(element["value"].getlocalId(), element)
+for element in self.content["value"].getcontent()])
+setattr(cls, "loadXMLTree", loadXMLTree)
 def resetcurrentExecutionOrderId(self):
 object.__setattr__(self, "currentExecutionOrderId", 0)
 setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId)
 raise TypeError, _("Can only generate execution order on FBD networks!")
 setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
 def appendcontentInstance(self, name, instance):
 if self.content["name"] in ["LD","FBD","SFC"]:
-self.content["value"].appendcontent({"name" : name, "value" : instance})
+element = {"name" : name, "value" : instance}
+self.content["value"].appendcontent(element)
+self.instances_dict[instance.getlocalId()] = element
 else:
 raise TypeError, _("%s body don't have instances!")%self.content["name"]
 setattr(cls, "appendcontentInstance", appendcontentInstance)
 def getcontentInstances(self):
 raise TypeError, _("%s body don't have instances!")%self.content["name"]
 setattr(cls, "getcontentInstances", getcontentInstances)
 def getcontentInstance(self, id):
 if self.content["name"] in ["LD","FBD","SFC"]:
-for element in self.content["value"].getcontent():
+instance = self.instances_dict.get(id, None)
-if element["value"].getlocalId() == id:
+if instance is not None:
-return element["value"]
+return instance["value"]
 return None
 else:
 raise TypeError, _("%s body don't have instances!")%self.content["name"]
 setattr(cls, "getcontentInstance", getcontentInstance)
 def getcontentRandomInstance(self, exclude):
 if self.content["name"] in ["LD","FBD","SFC"]:
-for element in self.content["value"].getcontent():
+ids = self.instances_dict.viewkeys() - exclude
-if element["value"].getlocalId() not in exclude:
+if len(ids) > 0:
-return element["value"]
+return self.instances_dict[ids.pop()]["value"]
 return None
 else:
 raise TypeError, _("%s body don't have instances!")%self.content["name"]
 setattr(cls, "getcontentRandomInstance", getcontentRandomInstance)
 raise TypeError, _("%s body don't have instances!")%self.content["name"]
 setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)
 def removecontentInstance(self, id):
 if self.content["name"] in ["LD","FBD","SFC"]:
-i = 0
+element = self.instances_dict.pop(id, None)
-removed = False
+if element is not None:
-elements = self.content["value"].getcontent()
+self.content["value"].getcontent().remove(element)
-while i < len(elements) and not removed:
+else:
-if elements[i]["value"].getlocalId() == id:
-self.content["value"].removecontent(i)
-removed = True
-i += 1
-if not removed:
 raise ValueError, _("Instance with id %d doesn't exist!")%id
 else:
 raise TypeError, "%s body don't have instances!"%self.content["name"]
 setattr(cls, "removecontentInstance", removecontentInstance)
 if self.content["name"] in ["IL","ST"]:
 return self.content["value"].gettext()
 else:
 raise TypeError, _("%s body don't have text!")%self.content["name"]
 setattr(cls, "gettext", gettext)
+def hasblock(self, block_type):
+if self.content["name"] in ["IL","ST"]:
+return self.content["value"].hasblock(block_type)
+else:
+raise TypeError, _("%s body don't have text!")%self.content["name"]
+setattr(cls, "hasblock", hasblock)
 def updateElementName(self, old_name, new_name):
 if self.content["name"] in ["IL", "ST"]:
 self.content["value"].updateElementName(old_name, new_name)
 else:

branch	1.1 Korean release
changeset 1280	72a826dfcfbb
parent 1276	29bfd39e8e7a
child 1281	47131e3388f4