beremiz: comparison plcopen/plcopen.py

equal deleted inserted replaced

-:6431f26aa501
+:3291024e00da
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor
+# This file is part of Beremiz, a Integrated Development Environment for
-#based on the plcopen standard.
+# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.
 #
-#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD
+# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD
 #
-#See COPYING file for copyrights details.
+# See COPYING file for copyrights details.
 #
-#This library is free software; you can redistribute it and/or
+# This program is free software; you can redistribute it and/or
-#modify it under the terms of the GNU General Public
+# modify it under the terms of the GNU General Public License
-#License as published by the Free Software Foundation; either
+# as published by the Free Software Foundation; either version 2
-#version 2.1 of the License, or (at your option) any later version.
+# of the License, or (at your option) any later version.
 #
-#This library is distributed in the hope that it will be useful,
+# This program is distributed in the hope that it will be useful,
-#but WITHOUT ANY WARRANTY; without even the implied warranty of
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
-#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#General Public License for more details.
+# GNU General Public License for more details.
 #
-#You should have received a copy of the GNU General Public
+# You should have received a copy of the GNU General Public License
-#License along with this library; if not, write to the Free Software
+# along with this program; if not, write to the Free Software
-#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 from xmlclass import *
 from types import *
 import os, re
 from lxml import etree
 if text == "":
 return (0, 0)
 lines = text.split("\n")
 return len(lines) - 1, len(lines[-1])
+def CompilePattern(criteria):
+flag = 0 if criteria["case_sensitive"] else re.IGNORECASE
+find_pattern = criteria["find_pattern"]
+if not criteria["regular_expression"]:
+find_pattern = re.escape(find_pattern)
+criteria["pattern"] = re.compile(find_pattern, flag)
 def TestTextElement(text, criteria):
 lines = text.splitlines()
-if not criteria["case_sensitive"]:
-text = text.upper()
 test_result = []
 result = criteria["pattern"].search(text)
 while result is not None:
 start = TextLenInRowColumn(text[:result.start()])
 end = TextLenInRowColumn(text[:result.end() - 1])
 test_result.append((start, end, "\n".join(lines[start[0]:end[0] + 1])))
 result = criteria["pattern"].search(text, result.end())
 return test_result
+def TextMatched(str1, str2):
+return str1 and str2 and (str1.upper() == str2.upper())
 PLCOpenParser = GenerateParserFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))
 PLCOpen_XPath = lambda xpath: etree.XPath(xpath, namespaces=PLCOpenParser.NSMAP)
 LOAD_POU_PROJECT_TEMPLATE = """
 cls = PLCOpenParser.GetElementClass("formattedText")
 if cls:
 def updateElementName(self, old_name, new_name):
 text = self.getanyText()
-index = text.find(old_name)
+pattern = re.compile('\\b' + old_name + '\\b', re.IGNORECASE)
-while index != -1:
+text = pattern.sub(new_name, text)
-if index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_"):
-index = text.find(old_name, index + len(old_name))
-elif index < len(text) - len(old_name) and (text[index + len(old_name)].isalnum() or text[index + len(old_name)] == "_"):
-index = text.find(old_name, index + len(old_name))
-else:
-text = text[:index] + new_name + text[index + len(old_name):]
-index = text.find(old_name, index + len(new_name))
 self.setanyText(text)
 setattr(cls, "updateElementName", updateElementName)
 def updateElementAddress(self, address_model, new_leading):
 text = self.getanyText()
 result = address_model.search(text, startpos)
 self.setanyText(text)
 setattr(cls, "updateElementAddress", updateElementAddress)
 def hasblock(self, block_type):
-text = self.getanyText().upper()
+text = self.getanyText()
-index = text.find(block_type.upper())
+pattern = re.compile('\\b' + block_type + '\\b', re.IGNORECASE)
-while index != -1:
+return pattern.search(text) is not None
-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.getanyText(), criteria)]
 setattr(cls, "Search", Search)
 return None
 setattr(cls, "getconfigurationResource", getconfigurationResource)
 def addconfigurationResource(self, config_name, name):
 if self.getconfigurationResource(config_name, name) is not None:
-raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!") % (name, config_name)
+msg = _("\"{a1}\" resource already exists in \"{a2}\" configuration !!!").format(a1 = name, a2 = config_name)
+raise ValueError, msg
 configuration = self.getconfiguration(config_name)
 if configuration is not None:
 new_resource = PLCOpenParser.CreateElement("resource", "configuration")
 new_resource.setname(name)
 configuration.appendresource(new_resource)
 resource = self.getconfigurationResource(config_name, name)
 if resource is not None:
 configuration.remove(resource)
 found = True
 if not found:
-raise ValueError, _("\"%s\" resource doesn't exist in \"%s\" configuration !!!")%(name, config_name)
+msg = _("\"{a1}\" resource doesn't exist in \"{a2}\" configuration !!!").format(a1 = name, a2 = config_name)
+raise ValueError, msg
 setattr(cls, "removeconfigurationResource", removeconfigurationResource)
 def updateElementName(self, old_name, new_name):
 for datatype in self.getdataTypes():
 datatype.updateElementName(old_name, new_name)
 def _updateConfigurationResourceElementName(self, old_name, new_name):
 for varlist in self.getglobalVars():
 for var in varlist.getvariable():
 var_address = var.getaddress()
 if var_address is not None:
-if var_address == old_name:
+if TextMatched(var_address, old_name):
 var.setaddress(new_name)
-if var.getname() == old_name:
+if TextMatched(var.getname(), old_name):
 var.setname(new_name)
 def _updateConfigurationResourceElementAddress(self, address_model, new_leading):
 for varlist in self.getglobalVars():
 for var in varlist.getvariable():
 setattr(cls, "Search", Search)
 cls = PLCOpenParser.GetElementClass("task", "resource")
 if cls:
 def updateElementName(self, old_name, new_name):
-if self.single == old_name:
+if TextMatched(self.single, old_name):
 self.single = new_name
-if self.interval == old_name:
+if TextMatched(self.interval, old_name):
 self.interval = new_name
 for instance in self.getpouInstance():
 instance.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 setattr(cls, "Search", Search)
 cls = PLCOpenParser.GetElementClass("pouInstance")
 if cls:
 def updateElementName(self, old_name, new_name):
-if self.typeName == old_name:
+if TextMatched(self.typeName, old_name):
 self.typeName = new_name
 setattr(cls, "updateElementName", updateElementName)
 def Search(self, criteria, parent_infos=[]):
 return _Search([("name", self.getname()),
 setattr(cls, "getdataTypeElements", getdataTypeElements)
 def getdataTypeElement(self, name):
 elements = self.dataTypes.getdataType()
 for element in elements:
-if element.getname() == name:
+if TextMatched(element.getname(), name):
 return element
 return None
 setattr(cls, "getdataTypeElement", getdataTypeElement)
 def appenddataTypeElement(self, name):
 setattr(cls, "insertdataTypeElement", insertdataTypeElement)
 def removedataTypeElement(self, name):
 found = False
 for element in self.dataTypes.getdataType():
-if element.getname() == name:
+if TextMatched(element.getname(), name):
 self.dataTypes.remove(element)
 found = True
 break
 if not found:
 raise ValueError, _("\"%s\" Data Type doesn't exist !!!")%name
 setattr(cls, "getpouElements", getpouElements)
 def getpouElement(self, name):
 elements = self.pous.getpou()
 for element in elements:
-if element.getname() == name:
+if TextMatched(element.getname(), name):
 return element
 return None
 setattr(cls, "getpouElement", getpouElement)
 def appendpouElement(self, name, pou_type, body_type):
 for element in self.pous.getpou():
-if element.getname() == name:
+if TextMatched(element.getname(), name):
 raise ValueError, _("\"%s\" POU already exists !!!")%name
 new_pou = PLCOpenParser.CreateElement("pou", "pous")
 self.pous.appendpou(new_pou)
 new_pou.setname(name)
 new_pou.setpouType(pou_type)
 setattr(cls, "insertpouElement", insertpouElement)
 def removepouElement(self, name):
 found = False
 for element in self.pous.getpou():
-if element.getname() == name:
+if TextMatched(element.getname(), name):
 self.pous.remove(element)
 found = True
 break
 if not found:
 raise ValueError, _("\"%s\" POU doesn't exist !!!")%name
 setattr(cls, "Search", Search)
 cls = PLCOpenParser.GetElementClass("derived", "dataType")
 if cls:
 def updateElementName(self, old_name, new_name):
-if self.name == old_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)]
 if self.interface is not None:
 content = self.interface.getcontent()
 for varlist in content:
 variables = varlist.getvariable()
 for var in variables:
-if var.getname() == old_name:
+if TextMatched(var.getname(), old_name):
 vartype_content = var.gettype().getcontent()
-if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == old_type:
+if vartype_content.getLocalTag() == "derived" and TextMatched(vartype_content.getname(), old_type):
 var.setname(new_name)
 vartype_content.setname(new_type)
 return
 setattr(cls, "changepouVar", changepouVar)
 def removepouVar(self, var_type, name):
 if self.interface is not None:
 content = self.interface.getcontent()
 for varlist in content:
 for var in varlist.getvariable():
-if var.getname() == name:
+if TextMatched(var.getname(), name):
 vartype_content = var.gettype().getcontent()
-if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == var_type:
+if vartype_content.getLocalTag() == "derived" and TextMatched(vartype_content.getname(), var_type):
 varlist.remove(var)
 if len(varlist.getvariable()) == 0:
 self.interface.remove(varlist)
 break
 setattr(cls, "removepouVar", removepouVar)
+def hasstep(self, name=None):
+if self.getbodyType() in ["SFC"]:
+for instance in self.getinstances():
+if isinstance(instance, PLCOpenParser.GetElementClass("step", "sfcObjects")) and TextMatched(instance.getname(), name):
+return True
+return False
+setattr(cls, "hasstep", hasstep)
 def hasblock(self, name=None, block_type=None):
 if self.getbodyType() in ["FBD", "LD", "SFC"]:
 for instance in self.getinstances():
 if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and
-(name and instance.getinstanceName() == name or
+(TextMatched(instance.getinstanceName(), name) or TextMatched(instance.gettypeName(), block_type))):
-block_type and instance.gettypeName() == block_type)):
 return True
 if self.transitions:
 for transition in self.transitions.gettransition():
 result = transition.hasblock(name, block_type)
 if result:
 transition = PLCOpenParser.CreateElement("transition", "transitions")
 self.transitions.appendtransition(transition)
 transition.setname(name)
 transition.setbodyType(body_type)
 if body_type == "ST":
-transition.setanyText(":= ;")
+transition.settext(":= ;")
-elif body_type == "IL":
-transition.setanyText("\tST\t%s"%name)
 setattr(cls, "addtransition", addtransition)
 def gettransition(self, name):
 if self.transitions is not None:
 for transition in self.transitions.gettransition():
-if transition.getname() == name:
+if TextMatched(transition.getname(), name):
 return transition
 return None
 setattr(cls, "gettransition", gettransition)
 def gettransitionList(self):
 def removetransition(self, name):
 if self.transitions is not None:
 removed = False
 for transition in self.transitions.gettransition():
-if transition.getname() == name:
+if TextMatched(transition.getname(), name):
 if transition.getbodyType() in ["FBD", "LD", "SFC"]:
 for instance in transition.getinstances():
 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
 self.removepouVar(instance.gettypeName(),
 instance.getinstanceName())
 setattr(cls, "addaction", addaction)
 def getaction(self, name):
 if self.actions is not None:
 for action in self.actions.getaction():
-if action.getname() == name:
+if TextMatched(action.getname(), name):
 return action
 return None
 setattr(cls, "getaction", getaction)
 def getactionList(self):
 def removeaction(self, name):
 if self.actions is not None:
 removed = False
 for action in self.actions.getaction():
-if action.getname() == name:
+if TextMatched(action.getname(), name):
 if action.getbodyType() in ["FBD", "LD", "SFC"]:
 for instance in action.getinstances():
 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
 self.removepouVar(instance.gettypeName(),
 instance.getinstanceName())
 if self.interface is not None:
 for content in self.interface.getcontent():
 for var in content.getvariable():
 var_address = var.getaddress()
 if var_address is not None:
-if var_address == old_name:
+if TextMatched(var_address, old_name):
 var.setaddress(new_name)
-if var.getname() == old_name:
+if TextMatched(var.getname(), old_name):
 var.setname(new_name)
 var_type_content = var.gettype().getcontent()
 if var_type_content.getLocalTag() == "derived":
-if var_type_content.getname() == old_name:
+if TextMatched(var_type_content.getname(), old_name):
 var_type_content.setname(new_name)
 self.body[0].updateElementName(old_name, new_name)
 for action in self.getactionList():
 action.updateElementName(old_name, new_name)
 for transition in self.gettransitionList():
 def removeVariableByAddress(self, address):
 if self.interface is not None:
 for content in self.interface.getcontent():
 for variable in content.getvariable():
-if variable.getaddress() == address:
+if TextMatched(variable.getaddress(), address):
 content.remove(variable)
 setattr(cls, "removeVariableByAddress", removeVariableByAddress)
 def removeVariableByFilter(self, address_model):
 if self.interface is not None:
 def Search(self, criteria, parent_infos=[]):
 search_result = []
 filter = criteria["filter"]
 if filter == "all" or self.getpouType() in filter:
-parent_infos = parent_infos + ["P::%s" % self.getname()]
+if parent_infos == []:
+parent_infos = parent_infos + ["P::%s" % self.getname()]
 search_result.extend(_Search([("name", self.getname())], criteria, parent_infos))
 if self.interface is not None:
 var_number = 0
 for content in self.interface.getcontent():
 variable_type = searchResultVarTypes.get(content, "var_local")
 def hasblock(self, name=None, block_type=None):
 if self.getbodyType() in ["FBD", "LD", "SFC"]:
 for instance in self.getinstances():
 if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and
-(name and instance.getinstanceName() == name or
+(TextMatched(instance.getinstanceName(), name) or TextMatched(instance.gettypeName(), block_type))):
-block_type and instance.gettypeName() == block_type)):
 return True
 elif block_type is not None:
 return self.body.hasblock(block_type)
 return False
 setattr(cls, "Search", Search)
 cls = PLCOpenParser.GetElementClass("body")
 if cls:
 cls.currentExecutionOrderId = 0
+cls.checkedBlocksDict = {}
 def resetcurrentExecutionOrderId(self):
 object.__setattr__(self, "currentExecutionOrderId", 0)
 setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId)
 def getnewExecutionOrderId(self):
 for element in self.content.getcontent():
 if not isinstance(element, (PLCOpenParser.GetElementClass("comment", "commonObjects"),
 PLCOpenParser.GetElementClass("connector", "commonObjects"),
 PLCOpenParser.GetElementClass("continuation", "commonObjects"))):
 element.setexecutionOrderId(0)
+self.checkedBlocksDict.clear()
 else:
 raise TypeError, _("Can only generate execution order on FBD networks!")
 setattr(cls, "resetexecutionOrder", resetexecutionOrder)
 def compileexecutionOrder(self):
 def compileelementExecutionOrder(self, link):
 if self.content.getLocalTag() == "FBD":
 localid = link.getrefLocalId()
 instance = self.getcontentInstance(localid)
+self.checkedBlocksDict[localid] = True
 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and instance.getexecutionOrderId() == 0:
 for variable in instance.inputVariables.getvariable():
 connections = variable.connectionPointIn.getconnections()
 if connections and len(connections) == 1:
-self.compileelementExecutionOrder(connections[0])
+if (self.checkedBlocksDict.has_key(connections[0].getrefLocalId()) == False):
-instance.setexecutionOrderId(self.getnewExecutionOrderId())
+self.compileelementExecutionOrder(connections[0])
+if instance.getexecutionOrderId() == 0:
+instance.setexecutionOrderId(self.getnewExecutionOrderId())
 elif isinstance(instance, PLCOpenParser.GetElementClass("continuation", "commonObjects")) and instance.getexecutionOrderId() == 0:
-name = instance.getname()
 for tmp_instance in self.getcontentInstances():
-if isinstance(tmp_instance, PLCOpenParser.GetElementClass("connector", "commonObjects")) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:
+if (isinstance(tmp_instance, PLCOpenParser.GetElementClass("connector", "commonObjects")) and
+TextMatched(tmp_instance.getname(), instance.getname()) and tmp_instance.getexecutionOrderId() == 0):
 connections = tmp_instance.connectionPointIn.getconnections()
 if connections and len(connections) == 1:
 self.compileelementExecutionOrder(connections[0])
 else:
 raise TypeError, _("Can only generate execution order on FBD networks!")
 bbox.union(_getConnectionsBoundingBox(input.connectionPointIn))
 return bbox
 setattr(cls, "getBoundingBox", getBoundingBox)
 def updateElementName(self, old_name, new_name):
-if self.typeName == old_name:
+if TextMatched(self.typeName, old_name):
 self.typeName = new_name
 setattr(cls, "updateElementName", updateElementName)
 def filterConnections(self, connections):
 for input in self.inputVariables.getvariable():
 _initElementClass("leftPowerRail", "ldObjects")
 _initElementClass("rightPowerRail", "ldObjects", "multiple")
 def _UpdateLDElementName(self, old_name, new_name):
-if self.variable == old_name:
+if TextMatched(self.variable, old_name):
 self.variable = new_name
 def _UpdateLDElementAddress(self, address_model, new_leading):
 self.variable = update_address(self.variable, address_model, new_leading)
 def updateElementName(self, old_name, new_name):
 if self.condition is not None:
 content = self.condition.getcontent()
 content_name = content.getLocalTag()
 if content_name == "reference":
-if content.getname() == old_name:
+if TextMatched(content.getname(), old_name):
 content.setname(new_name)
 elif content_name == "inline":
 content.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 return self.inline.gettext()
 return None
 setattr(cls, "getinlineContent", getinlineContent)
 def updateElementName(self, old_name, new_name):
-if self.reference is not None and self.reference.getname() == old_name:
+if self.reference is not None and TextMatched(self.reference.getname(), old_name):
 self.reference.setname(new_name)
 if self.inline is not None:
 self.inline.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 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):
-if self.expression == old_name:
+if TextMatched(self.expression, old_name):
 self.expression = new_name
 def _UpdateIOElementAddress(self, address_model, new_leading):
 self.expression = update_address(self.expression, address_model, new_leading)
 cls = _initElementClass("continuation", "commonObjects")
 if cls:
 setattr(cls, "Search", _SearchInConnector)
 def updateElementName(self, old_name, new_name):
-if self.name == old_name:
+if TextMatched(self.name, old_name):
 self.name = new_name
 setattr(cls, "updateElementName", updateElementName)
 cls = _initElementClass("connector", "commonObjects", "single")
 if cls:
 setattr(cls, "Search", _SearchInConnector)
 def updateElementName(self, old_name, new_name):
-if self.name == old_name:
+if TextMatched(self.name, old_name):
 self.name = new_name
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenParser.GetElementClass("connection")
 if cls:

changeset 1649	3291024e00da
parent 1629	80eee3c5a057
child 1680	6db967480b7d