--- a/CodeFileTreeNode.py Thu Sep 26 20:47:36 2013 +0900
+++ b/CodeFileTreeNode.py Fri Sep 27 09:32:39 2013 +0900
@@ -1,13 +1,14 @@
-import os
-from xml.dom import minidom
-import cPickle
-
-from xmlclass import GenerateClassesFromXSDstring, UpdateXMLClassGlobals
+import os, re
+
+from copy import deepcopy
+from lxml import etree
+from xmlclass import GenerateParserFromXSDstring
from PLCControler import UndoBuffer
CODEFILE_XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
-<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+ xmlns:xhtml="http://www.w3.org/1999/xhtml">
<xsd:element name="%(codefile_name)s">
<xsd:complexType>
<xsd:sequence>
@@ -65,22 +66,29 @@
[SECTION_TAG_ELEMENT % name
for name in self.SECTIONS_NAMES if name != "includes"])
- self.CodeFileClasses = GenerateClassesFromXSDstring(
+ self.CodeFileParser = GenerateParserFromXSDstring(
CODEFILE_XSD % sections_str)
+ self.CodeFileVariables = etree.XPath("variables/variable")
filepath = self.CodeFileName()
- self.CodeFile = self.CodeFileClasses[self.CODEFILE_NAME]()
if os.path.isfile(filepath):
xmlfile = open(filepath, 'r')
- tree = minidom.parse(xmlfile)
+ codefile_xml = xmlfile.read()
xmlfile.close()
- for child in tree.childNodes:
- if child.nodeType == tree.ELEMENT_NODE and child.nodeName in [self.CODEFILE_NAME]:
- self.CodeFile.loadXMLTree(child, ["xmlns", "xmlns:xsi", "xsi:schemaLocation"])
- self.CreateCodeFileBuffer(True)
+ codefile_xml = codefile_xml.replace(
+ '<%s>' % self.CODEFILE_NAME,
+ '<%s xmlns:xhtml="http://www.w3.org/1999/xhtml">' % self.CODEFILE_NAME)
+ for cre, repl in [
+ (re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),
+ (re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:
+ codefile_xml = cre.sub(repl, codefile_xml)
+ self.CodeFile = etree.fromstring(codefile_xml, self.CodeFileParser)
+ self.CreateCodeFileBuffer(True)
+
else:
+ self.CodeFile = self.CodeFileParser.CreateRoot()
self.CreateCodeFileBuffer(False)
self.OnCTNSave()
@@ -99,7 +107,7 @@
def SetVariables(self, variables):
self.CodeFile.variables.setvariable([])
for var in variables:
- variable = self.CodeFileClasses["variables_variable"]()
+ variable = self.CodeFileParser.CreateElement("variable", "variables")
variable.setname(var["Name"])
variable.settype(var["Type"])
variable.setinitial(var["Initial"])
@@ -107,7 +115,7 @@
def GetVariables(self):
datas = []
- for var in self.CodeFile.variables.getvariable():
+ for var in self.CodeFileVariables(self.CodeFile):
datas.append({"Name" : var.getname(),
"Type" : var.gettype(),
"Initial" : var.getinitial()})
@@ -117,10 +125,10 @@
for section in self.SECTIONS_NAMES:
section_code = parts.get(section)
if section_code is not None:
- getattr(self.CodeFile, section).settext(section_code)
+ getattr(self.CodeFile, section).setanyText(section_code)
def GetTextParts(self):
- return dict([(section, getattr(self.CodeFile, section).gettext())
+ return dict([(section, getattr(self.CodeFile, section).getanyText())
for section in self.SECTIONS_NAMES])
def CTNTestModified(self):
@@ -129,11 +137,12 @@
def OnCTNSave(self, from_project_path=None):
filepath = self.CodeFileName()
- text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
- text += self.CodeFile.generateXMLText(self.CODEFILE_NAME, 0)
-
xmlfile = open(filepath,"w")
- xmlfile.write(text.encode("utf-8"))
+ xmlfile.write(etree.tostring(
+ self.CodeFile,
+ pretty_print=True,
+ xml_declaration=True,
+ encoding='utf-8'))
xmlfile.close()
self.MarkCodeFileAsSaved()
@@ -144,39 +153,31 @@
return [(variable.getname(),
variable.gettype(),
variable.getinitial())
- for variable in self.CodeFile.variables.variable]
+ for variable in self.CodeFileVariables(self.CodeFile)]
#-------------------------------------------------------------------------------
# Current Buffering Management Functions
#-------------------------------------------------------------------------------
- def cPickle_loads(self, str_obj):
- UpdateXMLClassGlobals(self.CodeFileClasses)
- return cPickle.loads(str_obj)
-
- def cPickle_dumps(self, obj):
- UpdateXMLClassGlobals(self.CodeFileClasses)
- return cPickle.dumps(obj)
-
"""
Return a copy of the codefile model
"""
def Copy(self, model):
- return self.cPickle_loads(self.cPickle_dumps(model))
+ return deepcopy(model)
def CreateCodeFileBuffer(self, saved):
self.Buffering = False
- self.CodeFileBuffer = UndoBuffer(self.cPickle_dumps(self.CodeFile), saved)
+ self.CodeFileBuffer = UndoBuffer(self.CodeFileParser.Dumps(self.CodeFile), saved)
def BufferCodeFile(self):
- self.CodeFileBuffer.Buffering(self.cPickle_dumps(self.CodeFile))
+ self.CodeFileBuffer.Buffering(self.CodeFileParser.Dumps(self.CodeFile))
def StartBuffering(self):
self.Buffering = True
def EndBuffering(self):
if self.Buffering:
- self.CodeFileBuffer.Buffering(self.cPickle_dumps(self.CodeFile))
+ self.CodeFileBuffer.Buffering(self.CodeFileParser.Dumps(self.CodeFile))
self.Buffering = False
def MarkCodeFileAsSaved(self):
@@ -188,10 +189,10 @@
def LoadPrevious(self):
self.EndBuffering()
- self.CodeFile = self.cPickle_loads(self.CodeFileBuffer.Previous())
+ self.CodeFile = self.CodeFileParser.Loads(self.CodeFileBuffer.Previous())
def LoadNext(self):
- self.CodeFile = self.cPickle_loads(self.CodeFileBuffer.Next())
+ self.CodeFile = self.CodeFileParser.Loads(self.CodeFileBuffer.Next())
def GetBufferState(self):
first = self.CodeFileBuffer.IsFirst() and not self.Buffering
--- a/ConfigTreeNode.py Thu Sep 26 20:47:36 2013 +0900
+++ b/ConfigTreeNode.py Fri Sep 27 09:32:39 2013 +0900
@@ -9,15 +9,15 @@
import os,traceback,types
import shutil
-from xml.dom import minidom
-
-from xmlclass import GenerateClassesFromXSDstring
+from lxml import etree
+
+from xmlclass import GenerateParserFromXSDstring
from util.misc import GetClassImporter
from PLCControler import PLCControler, LOCATION_CONFNODE
from editors.ConfTreeNodeEditor import ConfTreeNodeEditor
-_BaseParamsClass = GenerateClassesFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>
+_BaseParamsParser = GenerateParserFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="BaseParams">
<xsd:complexType>
@@ -26,7 +26,7 @@
<xsd:attribute name="Enabled" type="xsd:boolean" use="optional" default="true"/>
</xsd:complexType>
</xsd:element>
- </xsd:schema>""")["BaseParams"]
+ </xsd:schema>""")
NameTypeSeparator = '@'
@@ -46,17 +46,15 @@
def _AddParamsMembers(self):
self.CTNParams = None
if self.XSD:
- self.Classes = GenerateClassesFromXSDstring(self.XSD)
- Classes = [(name, XSDclass) for name, XSDclass in self.Classes.items() if XSDclass.IsBaseClass]
- if len(Classes) == 1:
- name, XSDclass = Classes[0]
- obj = XSDclass()
- self.CTNParams = (name, obj)
- setattr(self, name, obj)
+ self.Parser = GenerateParserFromXSDstring(self.XSD)
+ obj = self.Parser.CreateRoot()
+ name = obj.getLocalTag()
+ self.CTNParams = (name, obj)
+ setattr(self, name, obj)
def __init__(self):
# Create BaseParam
- self.BaseParams = _BaseParamsClass()
+ self.BaseParams = _BaseParamsParser.CreateRoot()
self.MandatoryParams = ("BaseParams", self.BaseParams)
self._AddParamsMembers()
self.Children = {}
@@ -170,15 +168,21 @@
# generate XML for base XML parameters controller of the confnode
if self.MandatoryParams:
BaseXMLFile = open(self.ConfNodeBaseXmlFilePath(),'w')
- BaseXMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
- BaseXMLFile.write(self.MandatoryParams[1].generateXMLText(self.MandatoryParams[0], 0).encode("utf-8"))
+ BaseXMLFile.write(etree.tostring(
+ self.MandatoryParams[1],
+ pretty_print=True,
+ xml_declaration=True,
+ encoding='utf-8'))
BaseXMLFile.close()
# generate XML for XML parameters controller of the confnode
if self.CTNParams:
XMLFile = open(self.ConfNodeXmlFilePath(),'w')
- XMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
- XMLFile.write(self.CTNParams[1].generateXMLText(self.CTNParams[0], 0).encode("utf-8"))
+ XMLFile.write(etree.tostring(
+ self.CTNParams[1],
+ pretty_print=True,
+ xml_declaration=True,
+ encoding='utf-8'))
XMLFile.close()
# Call the confnode specific OnCTNSave method
@@ -581,8 +585,9 @@
if self.MandatoryParams:
try:
basexmlfile = open(self.ConfNodeBaseXmlFilePath(CTNName), 'r')
- basetree = minidom.parse(basexmlfile)
- self.MandatoryParams[1].loadXMLTree(basetree.childNodes[0])
+ self.BaseParams = etree.fromstring(
+ basexmlfile.read(), _BaseParamsParser)
+ self.MandatoryParams = ("BaseParams", self.BaseParams)
basexmlfile.close()
except Exception, exc:
self.GetCTRoot().logger.write_error(_("Couldn't load confnode base parameters %s :\n %s") % (CTNName, unicode(exc)))
@@ -592,8 +597,10 @@
if self.CTNParams:
try:
xmlfile = open(self.ConfNodeXmlFilePath(CTNName), 'r')
- tree = minidom.parse(xmlfile)
- self.CTNParams[1].loadXMLTree(tree.childNodes[0])
+ obj = etree.fromstring(xmlfile.read(), self.Parser)
+ name = obj.getLocalTag()
+ setattr(self, name, obj)
+ self.CTNParams = (name, obj)
xmlfile.close()
except Exception, exc:
self.GetCTRoot().logger.write_error(_("Couldn't load confnode parameters %s :\n %s") % (CTNName, unicode(exc)))
--- a/IDEFrame.py Thu Sep 26 20:47:36 2013 +0900
+++ b/IDEFrame.py Fri Sep 27 09:32:39 2013 +0900
@@ -2302,7 +2302,6 @@
if tagname is not None:
self._Refresh(TITLE, FILEMENU, EDITMENU, PROJECTTREE, POUINSTANCEVARIABLESPANEL)
self.EditProjectElement(ITEM_CONFIGURATION, tagname)
- dialog.Destroy()
def GenerateAddResourceFunction(self, config_name):
def OnAddResourceMenu(event):
--- a/PLCControler.py Thu Sep 26 20:47:36 2013 +0900
+++ b/PLCControler.py Fri Sep 27 09:32:39 2013 +0900
@@ -24,13 +24,13 @@
from xml.dom import minidom
from types import StringType, UnicodeType, TupleType
-import cPickle
+from lxml import etree
+from copy import deepcopy
import os,sys,re
import datetime
from time import localtime
-from plcopen import plcopen
-from plcopen.structures import *
+from plcopen import *
from graphics.GraphicCommons import *
from PLCGenerator import *
@@ -66,14 +66,14 @@
ITEM_VAR_INOUT
] = range(17, 24)
-VAR_CLASS_INFOS = {"Local" : (plcopen.interface_localVars, ITEM_VAR_LOCAL),
- "Global" : (plcopen.interface_globalVars, ITEM_VAR_GLOBAL),
- "External" : (plcopen.interface_externalVars, ITEM_VAR_EXTERNAL),
- "Temp" : (plcopen.interface_tempVars, ITEM_VAR_TEMP),
- "Input" : (plcopen.interface_inputVars, ITEM_VAR_INPUT),
- "Output" : (plcopen.interface_outputVars, ITEM_VAR_OUTPUT),
- "InOut" : (plcopen.interface_inOutVars, ITEM_VAR_INOUT)
- }
+VAR_CLASS_INFOS = {
+ "Local": ("localVars", ITEM_VAR_LOCAL),
+ "Global": ("globalVars", ITEM_VAR_GLOBAL),
+ "External": ("externalVars", ITEM_VAR_EXTERNAL),
+ "Temp": ("tempVars", ITEM_VAR_TEMP),
+ "Input": ("inputVars", ITEM_VAR_INPUT),
+ "Output": ("outputVars", ITEM_VAR_OUTPUT),
+ "InOut": ("inOutVars", ITEM_VAR_INOUT)}
POU_TYPES = {"program": ITEM_PROGRAM,
"functionBlock": ITEM_FUNCTIONBLOCK,
@@ -100,6 +100,252 @@
RESOURCES, PROPERTIES] = UNEDITABLE_NAMES
#-------------------------------------------------------------------------------
+# Helpers object for generating pou var list
+#-------------------------------------------------------------------------------
+
+def compute_dimensions(el):
+ return [
+ (dimension.get("lower"), dimension.get("upper"))
+ for dimension in el.findall("dimension")]
+
+def extract_param(el):
+ if el.tag == "Type" and el.text is None:
+ array = el.find("array")
+ return ('array', array.text, compute_dimensions(array))
+ elif el.tag == "Tree":
+ return generate_var_tree(el)
+ elif el.tag == "Edit":
+ return el.text == "True"
+ elif el.text is None:
+ return ''
+ return el.text
+
+def generate_var_tree(tree):
+ return ([
+ (var.get("name"), var.text, generate_var_tree(var))
+ for var in tree.findall("var")],
+ compute_dimensions(tree))
+
+class AddVariable(etree.XSLTExtension):
+
+ def __init__(self, variables):
+ etree.XSLTExtension.__init__(self)
+ self.Variables = variables
+
+ def execute(self, context, self_node, input_node, output_parent):
+ infos = etree.Element('var_infos')
+ self.process_children(context, infos)
+ self.Variables.append(
+ {el.tag.replace("_", " "): extract_param(el) for el in infos})
+
+class VarTree(etree.XSLTExtension):
+
+ def __init__(self, controller, debug):
+ etree.XSLTExtension.__init__(self)
+ self.Controller = controller
+ self.Debug = debug
+
+ def execute(self, context, self_node, input_node, output_parent):
+ typename = input_node.get("name")
+ pou_infos = self.Controller.GetPou(typename, self.Debug)
+ if pou_infos is not None:
+ self.apply_templates(context, pou_infos, output_parent)
+ return
+
+ datatype_infos = self.Controller.GetDataType(typename, self.Debug)
+ if datatype_infos is not None:
+ self.apply_templates(context, datatype_infos, output_parent)
+ return
+
+class VarIsEdited(etree.XSLTExtension):
+
+ def __init__(self, controller, debug):
+ etree.XSLTExtension.__init__(self)
+ self.Controller = controller
+ self.Debug = debug
+
+ def execute(self, context, self_node, input_node, output_parent):
+ typename = input_node.get("name")
+ output_parent.text = str(
+ self.Controller.GetPou(typename, self.Debug) is None)
+
+variables_infos_xslt = etree.parse(
+ os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"))
+
+#-------------------------------------------------------------------------------
+# Helpers object for generating pou variable instance list
+#-------------------------------------------------------------------------------
+
+def class_extraction(el, prt):
+ if prt in ["pou", "variable"]:
+ pou_type = POU_TYPES.get(el.text)
+ if pou_type is not None:
+ return pou_type
+ return VAR_CLASS_INFOS[el.text][1]
+ return {
+ "configuration": ITEM_CONFIGURATION,
+ "resource": ITEM_RESOURCE,
+ "action": ITEM_ACTION,
+ "transition": ITEM_TRANSITION,
+ "program": ITEM_PROGRAM}.get(prt)
+
+PARAM_VALUE_EXTRACTION = {
+ "name": lambda el, prt: el.text,
+ "class": class_extraction,
+ "type": lambda el, prt: None if el.text == "None" else el.text,
+ "edit": lambda el, prt: el.text == "True",
+ "debug": lambda el, prt: el.text == "True",
+ "variables": lambda el, prt: [
+ compute_instance_tree(chld)
+ for chld in el]}
+
+def compute_instance_tree(tree):
+ return {el.tag:
+ PARAM_VALUE_EXTRACTION[el.tag](el, tree.tag)
+ for el in tree}
+
+class IsEdited(etree.XSLTExtension):
+
+ def __init__(self, controller, debug):
+ etree.XSLTExtension.__init__(self)
+ self.Controller = controller
+ self.Debug = debug
+
+ def execute(self, context, self_node, input_node, output_parent):
+ typename = input_node.get("name")
+ project = self.Controller.GetProject(self.Debug)
+ output_parent.text = str(project.getpou(typename) is not None)
+
+class IsDebugged(etree.XSLTExtension):
+
+ def __init__(self, controller, debug):
+ etree.XSLTExtension.__init__(self)
+ self.Controller = controller
+ self.Debug = debug
+
+ def execute(self, context, self_node, input_node, output_parent):
+ typename = input_node.get("name")
+ project = self.Controller.GetProject(self.Debug)
+ pou_infos = project.getpou(typename)
+ if pou_infos is not None:
+ self.apply_templates(context, pou_infos, output_parent)
+ return
+
+ datatype_infos = self.Controller.GetDataType(typename, self.Debug)
+ if datatype_infos is not None:
+ self.apply_templates(context, datatype_infos, output_parent)
+ return
+
+ output_parent.text = "False"
+
+class PouVariableClass(etree.XSLTExtension):
+
+ def __init__(self, controller, debug):
+ etree.XSLTExtension.__init__(self)
+ self.Controller = controller
+ self.Debug = debug
+
+ def execute(self, context, self_node, input_node, output_parent):
+ pou_infos = self.Controller.GetPou(input_node.get("name"), self.Debug)
+ if pou_infos is not None:
+ self.apply_templates(context, pou_infos, output_parent)
+ return
+
+ self.process_children(context, output_parent)
+
+pou_variables_xslt = etree.parse(
+ os.path.join(ScriptDirectory, "plcopen", "pou_variables.xslt"))
+
+#-------------------------------------------------------------------------------
+# Helpers object for generating instances path list
+#-------------------------------------------------------------------------------
+
+class InstanceDefinition(etree.XSLTExtension):
+
+ def __init__(self, controller, debug):
+ etree.XSLTExtension.__init__(self)
+ self.Controller = controller
+ self.Debug = debug
+
+ def execute(self, context, self_node, input_node, output_parent):
+ instance_infos = etree.Element('infos')
+ self.process_children(context, instance_infos)
+
+ pou_infos = self.Controller.GetPou(instance_infos.get("name"), self.Debug)
+ if pou_infos is not None:
+ pou_instance = etree.Element('pou_instance',
+ pou_path=instance_infos.get("path"))
+ pou_instance.append(deepcopy(pou_infos))
+ self.apply_templates(context, pou_instance, output_parent)
+ return
+
+ datatype_infos = self.Controller.GetDataType(instance_infos.get("name"), self.Debug)
+ if datatype_infos is not None:
+ datatype_instance = etree.Element('datatype_instance',
+ datatype_path=instance_infos.get("path"))
+ datatype_instance.append(deepcopy(datatype_infos))
+ self.apply_templates(context, datatype_instance, output_parent)
+ return
+
+instances_path_xslt = etree.parse(
+ os.path.join(ScriptDirectory, "plcopen", "instances_path.xslt"))
+
+#-------------------------------------------------------------------------------
+# Helpers object for generating instance tagname
+#-------------------------------------------------------------------------------
+
+class InstanceTagName(etree.XSLTExtension):
+
+ def __init__(self, controller):
+ etree.XSLTExtension.__init__(self)
+ self.Controller = controller
+
+ def GetTagName(self, infos):
+ return ""
+
+ def execute(self, context, self_node, input_node, output_parent):
+ tagname_infos = etree.Element('infos')
+ self.process_children(context, tagname_infos)
+ tagname = etree.Element('tagname')
+ tagname.text = self.GetTagName(tagname_infos)
+ print etree.tostring(tagname)
+ try:
+ output_parent.append(tagname)
+ except:
+ pass
+
+class ConfigTagName(InstanceTagName):
+
+ def GetTagName(self, infos):
+ return self.Controller.ComputeConfigurationName(infos.get("name"))
+
+class ResourceTagName(InstanceTagName):
+
+ def GetTagName(self, infos):
+ return self.Controller.ComputeConfigurationResourceName(
+ infos.get("config_name"), infos.get("name"))
+
+class PouTagName(InstanceTagName):
+
+ def GetTagName(self, infos):
+ return self.Controller.ComputePouName(infos.get("name"))
+
+class ActionTagName(InstanceTagName):
+
+ def GetTagName(self, infos):
+ return self.Controller.ComputePouActionName(
+ infos.get("pou_name"), infos.get("name"))
+
+class TransitionTagName(InstanceTagName):
+
+ def GetTagName(self, infos):
+ return self.Controller.ComputePouTransitionName(
+ infos.get("pou_name"), infos.get("name"))
+
+instance_tagname_xslt = etree.parse(
+ os.path.join(ScriptDirectory, "plcopen", "instance_tagname.xslt"))
+
+#-------------------------------------------------------------------------------
# Undo Buffer for PLCOpenEditor
#-------------------------------------------------------------------------------
@@ -215,7 +461,7 @@
self.ProgramFilePath = ""
def GetQualifierTypes(self):
- return plcopen.QualifierList
+ return QualifierList
def GetProject(self, debug = False):
if debug and self.CurrentCompiledProject is not None:
@@ -234,11 +480,12 @@
# Create a new project by replacing the current one
def CreateNewProject(self, properties):
# Create the project
- self.Project = plcopen.project()
+ self.Project = PLCOpenParser.CreateRoot()
properties["creationDateTime"] = datetime.datetime(*localtime()[:6])
self.Project.setfileHeader(properties)
self.Project.setcontentHeader(properties)
self.SetFilePath("")
+
# Initialize the project buffer
self.CreateProjectBuffer(False)
self.ProgramChunks = []
@@ -388,223 +635,49 @@
return infos
return None
- def GetPouVariableInfos(self, project, variable, var_class, debug=False):
- vartype_content = variable.gettype().getcontent()
- if vartype_content["name"] == "derived":
- var_type = vartype_content["value"].getname()
- pou_type = None
- pou = project.getpou(var_type)
- if pou is not None:
- pou_type = pou.getpouType()
- edit = debug = pou_type is not None
- if pou_type is None:
- block_infos = self.GetBlockType(var_type, debug = debug)
- if block_infos is not None:
- pou_type = block_infos["type"]
- if pou_type is not None:
- var_class = None
- if pou_type == "program":
- var_class = ITEM_PROGRAM
- elif pou_type != "function":
- var_class = ITEM_FUNCTIONBLOCK
- if var_class is not None:
- return {"name": variable.getname(),
- "type": var_type,
- "class": var_class,
- "edit": edit,
- "debug": debug}
- elif var_type in self.GetDataTypes(debug = debug):
- return {"name": variable.getname(),
- "type": var_type,
- "class": var_class,
- "edit": False,
- "debug": False}
- elif vartype_content["name"] in ["string", "wstring"]:
- return {"name": variable.getname(),
- "type": vartype_content["name"].upper(),
- "class": var_class,
- "edit": False,
- "debug": True}
- else:
- return {"name": variable.getname(),
- "type": vartype_content["name"],
- "class": var_class,
- "edit": False,
- "debug": True}
- return None
-
def GetPouVariables(self, tagname, debug = False):
vars = []
pou_type = None
project = self.GetProject(debug)
if project is not None:
+ pou_variable_xslt_tree = etree.XSLT(
+ pou_variables_xslt, extensions = {
+ ("pou_vars_ns", "is_edited"): IsEdited(self, debug),
+ ("pou_vars_ns", "is_debugged"): IsDebugged(self, debug),
+ ("pou_vars_ns", "pou_class"): PouVariableClass(self, debug)})
+
words = tagname.split("::")
if words[0] == "P":
- pou = project.getpou(words[1])
- if pou is not None:
- pou_type = pou.getpouType()
- if (pou_type in ["program", "functionBlock"] and
- pou.interface is not None):
- # Extract variables from every varLists
- for varlist_type, varlist in pou.getvars():
- var_infos = VAR_CLASS_INFOS.get(varlist_type, None)
- if var_infos is not None:
- var_class = var_infos[1]
- else:
- var_class = ITEM_VAR_LOCAL
- for variable in varlist.getvariable():
- var_infos = self.GetPouVariableInfos(project, variable, var_class, debug)
- if var_infos is not None:
- vars.append(var_infos)
- if pou.getbodyType() == "SFC":
- for transition in pou.gettransitionList():
- vars.append({
- "name": transition.getname(),
- "type": None,
- "class": ITEM_TRANSITION,
- "edit": True,
- "debug": True})
- for action in pou.getactionList():
- vars.append({
- "name": action.getname(),
- "type": None,
- "class": ITEM_ACTION,
- "edit": True,
- "debug": True})
- return {"class": POU_TYPES[pou_type],
- "type": words[1],
- "variables": vars,
- "edit": True,
- "debug": True}
- else:
- block_infos = self.GetBlockType(words[1], debug = debug)
- if (block_infos is not None and
- block_infos["type"] in ["program", "functionBlock"]):
- for varname, vartype, varmodifier in block_infos["inputs"]:
- vars.append({"name" : varname,
- "type" : vartype,
- "class" : ITEM_VAR_INPUT,
- "edit": False,
- "debug": True})
- for varname, vartype, varmodifier in block_infos["outputs"]:
- vars.append({"name" : varname,
- "type" : vartype,
- "class" : ITEM_VAR_OUTPUT,
- "edit": False,
- "debug": True})
- return {"class": POU_TYPES[block_infos["type"]],
- "type": None,
- "variables": vars,
- "edit": False,
- "debug": False}
- elif words[0] in ['A', 'T']:
- pou_vars = self.GetPouVariables(self.ComputePouName(words[1]), debug)
- if pou_vars is not None:
- if words[0] == 'A':
- element_type = ITEM_ACTION
- elif words[0] == 'T':
- element_type = ITEM_TRANSITION
- return {"class": element_type,
- "type": None,
- "variables": [var for var in pou_vars["variables"]
- if var["class"] not in [ITEM_ACTION, ITEM_TRANSITION]],
- "edit": True,
- "debug": True}
- elif words[0] in ['C', 'R']:
- if words[0] == 'C':
- element_type = ITEM_CONFIGURATION
- element = project.getconfiguration(words[1])
- if element is not None:
- for resource in element.getresource():
- vars.append({"name": resource.getname(),
- "type": None,
- "class": ITEM_RESOURCE,
- "edit": True,
- "debug": False})
- elif words[0] == 'R':
- element_type = ITEM_RESOURCE
- element = project.getconfigurationResource(words[1], words[2])
- if element is not None:
- for task in element.gettask():
- for pou in task.getpouInstance():
- vars.append({"name": pou.getname(),
- "type": pou.gettypeName(),
- "class": ITEM_PROGRAM,
- "edit": True,
- "debug": True})
- for pou in element.getpouInstance():
- vars.append({"name": pou.getname(),
- "type": pou.gettypeName(),
- "class": ITEM_PROGRAM,
- "edit": True,
- "debug": True})
- if element is not None:
- for varlist in element.getglobalVars():
- for variable in varlist.getvariable():
- var_infos = self.GetPouVariableInfos(project, variable, ITEM_VAR_GLOBAL, debug)
- if var_infos is not None:
- vars.append(var_infos)
- return {"class": element_type,
- "type": None,
- "variables": vars,
- "edit": True,
- "debug": False}
- return None
-
- def RecursiveSearchPouInstances(self, project, pou_type, parent_path, varlists, debug = False):
- instances = []
- for varlist in varlists:
- for variable in varlist.getvariable():
- vartype_content = variable.gettype().getcontent()
- if vartype_content["name"] == "derived":
- var_path = "%s.%s" % (parent_path, variable.getname())
- var_type = vartype_content["value"].getname()
- if var_type == pou_type:
- instances.append(var_path)
- else:
- pou = project.getpou(var_type)
- if pou is not None and project.ElementIsUsedBy(pou_type, var_type):
- instances.extend(
- self.RecursiveSearchPouInstances(
- project, pou_type, var_path,
- [varlist for type, varlist in pou.getvars()],
- debug))
- return instances
-
+ obj = self.GetPou(words[1], debug)
+ else:
+ obj = self.GetEditedElement(tagname, debug)
+ if obj is not None:
+ return compute_instance_tree(
+ pou_variable_xslt_tree(obj).getroot())
+ return None
+
+ def GetInstanceList(self, root, name, debug = False):
+ project = self.GetProject(debug)
+ if project is not None:
+ instances_path_xslt_tree = etree.XSLT(
+ instances_path_xslt,
+ extensions = {
+ ("instances_ns", "instance_definition"):
+ InstanceDefinition(self, debug)})
+
+ return instances_path_xslt_tree(root,
+ instance_type=etree.XSLT.strparam(name)).getroot()
+ return None
+
def SearchPouInstances(self, tagname, debug = False):
project = self.GetProject(debug)
if project is not None:
words = tagname.split("::")
if words[0] == "P":
- instances = []
- for config in project.getconfigurations():
- config_name = config.getname()
- instances.extend(
- self.RecursiveSearchPouInstances(
- project, words[1], config_name,
- config.getglobalVars(), debug))
- for resource in config.getresource():
- res_path = "%s.%s" % (config_name, resource.getname())
- instances.extend(
- self.RecursiveSearchPouInstances(
- project, words[1], res_path,
- resource.getglobalVars(), debug))
- pou_instances = resource.getpouInstance()[:]
- for task in resource.gettask():
- pou_instances.extend(task.getpouInstance())
- for pou_instance in pou_instances:
- pou_path = "%s.%s" % (res_path, pou_instance.getname())
- pou_type = pou_instance.gettypeName()
- if pou_type == words[1]:
- instances.append(pou_path)
- pou = project.getpou(pou_type)
- if pou is not None and project.ElementIsUsedBy(words[1], pou_type):
- instances.extend(
- self.RecursiveSearchPouInstances(
- project, words[1], pou_path,
- [varlist for type, varlist in pou.getvars()],
- debug))
- return instances
+ result = self.GetInstanceList(project, words[1])
+ if result is not None:
+ return [instance.get("path") for instance in result]
+ return []
elif words[0] == 'C':
return [words[1]]
elif words[0] == 'R':
@@ -615,99 +688,24 @@
self.ComputePouName(words[1]), debug)]
return []
- def RecursiveGetPouInstanceTagName(self, project, pou_type, parts, debug = False):
- pou = project.getpou(pou_type)
- if pou is not None:
- if len(parts) == 0:
- return self.ComputePouName(pou_type)
-
- for varlist_type, varlist in pou.getvars():
- for variable in varlist.getvariable():
- if variable.getname() == parts[0]:
- vartype_content = variable.gettype().getcontent()
- if vartype_content["name"] == "derived":
- return self.RecursiveGetPouInstanceTagName(
- project,
- vartype_content["value"].getname(),
- parts[1:], debug)
-
- if pou.getbodyType() == "SFC" and len(parts) == 1:
- for action in pou.getactionList():
- if action.getname() == parts[0]:
- return self.ComputePouActionName(pou_type, parts[0])
- for transition in pou.gettransitionList():
- if transition.getname() == parts[0]:
- return self.ComputePouTransitionName(pou_type, parts[0])
- else:
- block_infos = self.GetBlockType(pou_type, debug=debug)
- if (block_infos is not None and
- block_infos["type"] in ["program", "functionBlock"]):
-
- if len(parts) == 0:
- return self.ComputePouName(pou_type)
-
- for varname, vartype, varmodifier in block_infos["inputs"] + block_infos["outputs"]:
- if varname == parts[0]:
- return self.RecursiveGetPouInstanceTagName(project, vartype, parts[1:], debug)
- return None
-
- def GetGlobalInstanceTagName(self, project, element, parts, debug = False):
- for varlist in element.getglobalVars():
- for variable in varlist.getvariable():
- if variable.getname() == parts[0]:
- vartype_content = variable.gettype().getcontent()
- if vartype_content["name"] == "derived":
- if len(parts) == 1:
- return self.ComputePouName(
- vartype_content["value"].getname())
- else:
- return self.RecursiveGetPouInstanceTagName(
- project,
- vartype_content["value"].getname(),
- parts[1:], debug)
- return None
-
def GetPouInstanceTagName(self, instance_path, debug = False):
project = self.GetProject(debug)
- parts = instance_path.split(".")
- if len(parts) == 1:
- return self.ComputeConfigurationName(parts[0])
- elif len(parts) == 2:
- for config in project.getconfigurations():
- if config.getname() == parts[0]:
- result = self.GetGlobalInstanceTagName(project,
- config,
- parts[1:],
- debug)
- if result is not None:
- return result
- return self.ComputeConfigurationResourceName(parts[0], parts[1])
- else:
- for config in project.getconfigurations():
- if config.getname() == parts[0]:
- for resource in config.getresource():
- if resource.getname() == parts[1]:
- pou_instances = resource.getpouInstance()[:]
- for task in resource.gettask():
- pou_instances.extend(task.getpouInstance())
- for pou_instance in pou_instances:
- if pou_instance.getname() == parts[2]:
- if len(parts) == 3:
- return self.ComputePouName(
- pou_instance.gettypeName())
- else:
- return self.RecursiveGetPouInstanceTagName(
- project,
- pou_instance.gettypeName(),
- parts[3:], debug)
- return self.GetGlobalInstanceTagName(project,
- resource,
- parts[2:],
- debug)
- return self.GetGlobalInstanceTagName(project,
- config,
- parts[1:],
- debug)
+
+ instance_tagname_xslt_tree = etree.XSLT(
+ instance_tagname_xslt,
+ extensions = {
+ ("instance_tagname_ns", "instance_definition"): InstanceDefinition(self, debug),
+ ("instance_tagname_ns", "config_tagname"): ConfigTagName(self),
+ ("instance_tagname_ns", "resource_tagname"): ResourceTagName(self),
+ ("instance_tagname_ns", "pou_tagname"): PouTagName(self),
+ ("instance_tagname_ns", "action_tagname"): ActionTagName(self),
+ ("instance_tagname_ns", "transition_tagname"): TransitionTagName(self)})
+
+ result = instance_tagname_xslt_tree(project,
+ instance_path=etree.XSLT.strparam(instance_path)).getroot()
+ if result is not None:
+ return result.text
+
return None
def GetInstanceInfos(self, instance_path, debug = False):
@@ -730,21 +728,21 @@
def DataTypeIsUsed(self, name, debug = False):
project = self.GetProject(debug)
if project is not None:
- return project.ElementIsUsed(name) or project.DataTypeIsDerived(name)
+ return self.GetInstanceList(project, name, debug) is not None
return False
# Return if pou given by name is used by another pou
def PouIsUsed(self, name, debug = False):
project = self.GetProject(debug)
if project is not None:
- return project.ElementIsUsed(name)
+ return self.GetInstanceList(project, name, debug) is not None
return False
# Return if pou given by name is directly or undirectly used by the reference pou
def PouIsUsedBy(self, name, reference, debug = False):
- project = self.GetProject(debug)
- if project is not None:
- return project.ElementIsUsedBy(name, reference)
+ pou_infos = self.GetPou(reference, debug)
+ if pou_infos is not None:
+ return self.GetInstanceList(pou_infos, name, debug) is not None
return False
def GenerateProgram(self, filepath=None):
@@ -832,14 +830,13 @@
pou = self.Project.getpou(name)
if pou is not None:
pou.setpouType(pou_type)
- self.Project.RefreshCustomBlockTypes()
self.BufferProject()
def GetPouXml(self, pou_name):
if self.Project is not None:
pou = self.Project.getpou(pou_name)
if pou is not None:
- return pou.generateXMLText('pou', 0)
+ return pou.tostring()
return None
def PastePou(self, pou_type, pou_xml):
@@ -847,47 +844,40 @@
Adds the POU defined by 'pou_xml' to the current project with type 'pou_type'
'''
try:
- tree = minidom.parseString(pou_xml.encode("utf-8"))
- root = tree.childNodes[0]
+ new_pou = LoadPou(pou_xml)
except:
return _("Couldn't paste non-POU object.")
-
- if root.nodeName == "pou":
- new_pou = plcopen.pous_pou()
- new_pou.loadXMLTree(root)
-
- name = new_pou.getname()
+
+ name = new_pou.getname()
+
+ idx = 0
+ new_name = name
+ while self.Project.getpou(new_name):
+ # a POU with that name already exists.
+ # make a new name and test if a POU with that name exists.
+ # append an incrementing numeric suffix to the POU name.
+ idx += 1
+ new_name = "%s%d" % (name, idx)
- idx = 0
- new_name = name
- while self.Project.getpou(new_name):
- # a POU with that name already exists.
- # make a new name and test if a POU with that name exists.
- # append an incrementing numeric suffix to the POU name.
- idx += 1
- new_name = "%s%d" % (name, idx)
-
- # we've found a name that does not already exist, use it
- new_pou.setname(new_name)
+ # we've found a name that does not already exist, use it
+ new_pou.setname(new_name)
+
+ if pou_type is not None:
+ orig_type = new_pou.getpouType()
+
+ # prevent violations of POU content restrictions:
+ # function blocks cannot be pasted as functions,
+ # programs cannot be pasted as functions or function blocks
+ if orig_type == 'functionBlock' and pou_type == 'function' or \
+ orig_type == 'program' and pou_type in ['function', 'functionBlock']:
+ return _('''%s "%s" can't be pasted as a %s.''') % (orig_type, name, pou_type)
- if pou_type is not None:
- orig_type = new_pou.getpouType()
-
- # prevent violations of POU content restrictions:
- # function blocks cannot be pasted as functions,
- # programs cannot be pasted as functions or function blocks
- if orig_type == 'functionBlock' and pou_type == 'function' or \
- orig_type == 'program' and pou_type in ['function', 'functionBlock']:
- return _('''%s "%s" can't be pasted as a %s.''') % (orig_type, name, pou_type)
-
- new_pou.setpouType(pou_type)
-
- self.Project.insertpou(-1, new_pou)
- self.BufferProject()
-
- return self.ComputePouName(new_name),
- else:
- return _("Couldn't paste non-POU object.")
+ new_pou.setpouType(pou_type)
+
+ self.Project.insertpou(-1, new_pou)
+ self.BufferProject()
+
+ return self.ComputePouName(new_name),
# Remove a Pou from project
def ProjectRemovePou(self, pou_name):
@@ -982,8 +972,6 @@
if datatype is not None:
datatype.setname(new_name)
self.Project.updateElementName(old_name, new_name)
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshDataTypeHierarchy()
self.BufferProject()
# Change the name of a pou
@@ -994,8 +982,6 @@
if pou is not None:
pou.setname(new_name)
self.Project.updateElementName(old_name, new_name)
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshCustomBlockTypes()
self.BufferProject()
# Change the name of a pou transition
@@ -1032,7 +1018,6 @@
for var in varlist.getvariable():
if var.getname() == old_name:
var.setname(new_name)
- self.Project.RefreshCustomBlockTypes()
self.BufferProject()
# Change the name of a configuration
@@ -1071,7 +1056,6 @@
pou = project.getpou(name)
if pou is not None:
pou.setdescription(description)
- project.RefreshCustomBlockTypes()
self.BufferProject()
# Return the type of the pou given by its name
@@ -1170,9 +1154,9 @@
current_type = next_type
infos = VAR_CLASS_INFOS.get(var["Class"], None)
if infos is not None:
- current_varlist = infos[0]()
+ current_varlist = PLCOpenParser.CreateElement(infos[0], "interface")
else:
- current_varlist = plcopen.varList()
+ current_varlist = PLCOpenParser.CreateElement("varList")
varlist_list.append((var["Class"], current_varlist))
if var["Option"] == "Constant":
current_varlist.setconstant(True)
@@ -1181,49 +1165,47 @@
elif var["Option"] == "Non-Retain":
current_varlist.setnonretain(True)
# Create variable and change its properties
- tempvar = plcopen.varListPlain_variable()
+ tempvar = PLCOpenParser.CreateElement("variable", "varListPlain")
tempvar.setname(var["Name"])
- var_type = plcopen.dataType()
+ var_type = PLCOpenParser.CreateElement("type", "variable")
if isinstance(var["Type"], TupleType):
if var["Type"][0] == "array":
array_type, base_type_name, dimensions = var["Type"]
- array = plcopen.derivedTypes_array()
+ array = PLCOpenParser.CreateElement("array", "dataType")
+ baseType = PLCOpenParser.CreateElement("baseType", "array")
+ array.setbaseType(baseType)
for i, dimension in enumerate(dimensions):
- dimension_range = plcopen.rangeSigned()
- dimension_range.setlower(dimension[0])
- dimension_range.setupper(dimension[1])
+ dimension_range = PLCOpenParser.CreateElement("dimension", "array")
if i == 0:
array.setdimension([dimension_range])
else:
array.appenddimension(dimension_range)
+ dimension_range.setlower(dimension[0])
+ dimension_range.setupper(dimension[1])
if base_type_name in self.GetBaseTypes():
- if base_type_name == "STRING":
- array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif base_type_name == "WSTRING":
- array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
- else:
- array.baseType.setcontent({"name" : base_type_name, "value" : None})
+ baseType.setcontent(PLCOpenParser.CreateElement(
+ base_type_name.lower()
+ if base_type_name in ["STRING", "WSTRING"]
+ else base_type_name, "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(base_type_name)
- array.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
- var_type.setcontent({"name" : "array", "value" : array})
+ baseType.setcontent(derived_datatype)
+ var_type.setcontent(array)
elif var["Type"] in self.GetBaseTypes():
- if var["Type"] == "STRING":
- var_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif var["Type"] == "WSTRING":
- var_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
- else:
- var_type.setcontent({"name" : var["Type"], "value" : None})
+ var_type.setcontent(PLCOpenParser.CreateElement(
+ var["Type"].lower()
+ if var["Type"] in ["STRING", "WSTRING"]
+ else var["Type"], "dataType"))
else:
- derived_type = plcopen.derivedTypes_derived()
+ derived_type = PLCOpenParser.CreateElement("derived", "dataType")
derived_type.setname(var["Type"])
- var_type.setcontent({"name" : "derived", "value" : derived_type})
+ var_type.setcontent(derived_type)
tempvar.settype(var_type)
if var["Initial Value"] != "":
- value = plcopen.value()
+ value = PLCOpenParser.CreateElement("initialValue", "variable")
value.setvalue(var["Initial Value"])
tempvar.setinitialValue(value)
if var["Location"] != "":
@@ -1231,80 +1213,37 @@
else:
tempvar.setaddress(None)
if var['Documentation'] != "":
- ft = plcopen.formattedText()
- ft.settext(var['Documentation'])
+ ft = PLCOpenParser.CreateElement("documentation", "variable")
+ ft.setanyText(var['Documentation'])
tempvar.setdocumentation(ft)
# Add variable to varList
current_varlist.appendvariable(tempvar)
return varlist_list
- def GetVariableDictionary(self, varlist, var):
- '''
- convert a PLC variable to the dictionary representation
- returned by Get*Vars)
- '''
-
- tempvar = {"Name": var.getname()}
-
- vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- tempvar["Type"] = vartype_content["value"].getname()
- elif vartype_content["name"] == "array":
- dimensions = []
- for dimension in vartype_content["value"].getdimension():
- dimensions.append((dimension.getlower(), dimension.getupper()))
- base_type = vartype_content["value"].baseType.getcontent()
- if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
- base_type_name = base_type["name"].upper()
- else:
- base_type_name = base_type["value"].getname()
- tempvar["Type"] = ("array", base_type_name, dimensions)
- elif vartype_content["name"] in ["string", "wstring"]:
- tempvar["Type"] = vartype_content["name"].upper()
- else:
- tempvar["Type"] = vartype_content["name"]
-
- tempvar["Edit"] = True
-
- initial = var.getinitialValue()
- if initial:
- tempvar["Initial Value"] = initial.getvalue()
- else:
- tempvar["Initial Value"] = ""
-
- address = var.getaddress()
- if address:
- tempvar["Location"] = address
- else:
- tempvar["Location"] = ""
-
- if varlist.getconstant():
- tempvar["Option"] = "Constant"
- elif varlist.getretain():
- tempvar["Option"] = "Retain"
- elif varlist.getnonretain():
- tempvar["Option"] = "Non-Retain"
- else:
- tempvar["Option"] = ""
-
- doc = var.getdocumentation()
- if doc:
- tempvar["Documentation"] = doc.gettext()
- else:
- tempvar["Documentation"] = ""
-
- return tempvar
-
+ def GetVariableDictionary(self, object_with_vars, debug=False):
+ variables = []
+
+ variables_infos_xslt_tree = etree.XSLT(
+ variables_infos_xslt, extensions = {
+ ("var_infos_ns", "add_variable"): AddVariable(variables),
+ ("var_infos_ns", "var_tree"): VarTree(self, debug),
+ ("var_infos_ns", "is_edited"): VarIsEdited(self, debug)})
+ variables_infos_xslt_tree(object_with_vars)
+
+ return variables
+
# Add a global var to configuration to configuration
- def AddConfigurationGlobalVar(self, config_name, type, var_name,
+ def AddConfigurationGlobalVar(self, config_name, var_type, var_name,
location="", description=""):
if self.Project is not None:
# Found the configuration corresponding to name
configuration = self.Project.getconfiguration(config_name)
if configuration is not None:
# Set configuration global vars
- configuration.addglobalVar(type, var_name, location, description)
+ configuration.addglobalVar(
+ self.GetVarTypeObject(var_type),
+ var_name, location, description)
# Replace the configuration globalvars by those given
def SetConfigurationGlobalVars(self, name, vars):
@@ -1313,25 +1252,21 @@
configuration = self.Project.getconfiguration(name)
if configuration is not None:
# Set configuration global vars
- configuration.setglobalVars([])
- for vartype, varlist in self.ExtractVarLists(vars):
- configuration.globalVars.append(varlist)
+ configuration.setglobalVars([
+ varlist for vartype, varlist
+ in self.ExtractVarLists(vars)])
# Return the configuration globalvars
def GetConfigurationGlobalVars(self, name, debug = False):
- vars = []
project = self.GetProject(debug)
if project is not None:
# Found the configuration corresponding to name
configuration = project.getconfiguration(name)
if configuration is not None:
- # Extract variables from every varLists
- for varlist in configuration.getglobalVars():
- for var in varlist.getvariable():
- tempvar = self.GetVariableDictionary(varlist, var)
- tempvar["Class"] = "Global"
- vars.append(tempvar)
- return vars
+ # Extract variables defined in configuration
+ return self.GetVariableDictionary(configuration, debug)
+
+ return []
# Return configuration variable names
def GetConfigurationVariableNames(self, config_name = None, debug = False):
@@ -1354,25 +1289,21 @@
resource = self.Project.getconfigurationResource(config_name, name)
# Set resource global vars
if resource is not None:
- resource.setglobalVars([])
- for vartype, varlist in self.ExtractVarLists(vars):
- resource.globalVars.append(varlist)
+ resource.setglobalVars([
+ varlist for vartype, varlist
+ in self.ExtractVarLists(vars)])
# Return the resource globalvars
def GetConfigurationResourceGlobalVars(self, config_name, name, debug = False):
- vars = []
project = self.GetProject(debug)
if project is not None:
# Found the resource corresponding to name
resource = project.getconfigurationResource(config_name, name)
- if resource:
- # Extract variables from every varLists
- for varlist in resource.getglobalVars():
- for var in varlist.getvariable():
- tempvar = self.GetVariableDictionary(varlist, var)
- tempvar["Class"] = "Global"
- vars.append(tempvar)
- return vars
+ if resource is not None:
+ # Extract variables defined in configuration
+ return self.GetVariableDictionary(resource, debug)
+
+ return []
# Return resource variable names
def GetConfigurationResourceVariableNames(self,
@@ -1390,73 +1321,15 @@
for varlist in resource.globalVars],
[])])
return variables
-
- # Recursively generate element name tree for a structured variable
- def GenerateVarTree(self, typename, debug = False):
- project = self.GetProject(debug)
- if project is not None:
- blocktype = self.GetBlockType(typename, debug = debug)
- if blocktype is not None:
- tree = []
- en = False
- eno = False
- for var_name, var_type, var_modifier in blocktype["inputs"] + blocktype["outputs"]:
- en |= var_name.upper() == "EN"
- eno |= var_name.upper() == "ENO"
- tree.append((var_name, var_type, self.GenerateVarTree(var_type, debug)))
- if not eno:
- tree.insert(0, ("ENO", "BOOL", ([], [])))
- if not en:
- tree.insert(0, ("EN", "BOOL", ([], [])))
- return tree, []
- datatype = project.getdataType(typename)
- if datatype is None:
- datatype = self.GetConfNodeDataType(typename)
- if datatype is not None:
- tree = []
- basetype_content = datatype.baseType.getcontent()
- if basetype_content["name"] == "derived":
- return self.GenerateVarTree(basetype_content["value"].getname())
- elif basetype_content["name"] == "array":
- dimensions = []
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["name"] == "derived":
- tree = self.GenerateVarTree(base_type["value"].getname())
- if len(tree[1]) == 0:
- tree = tree[0]
- for dimension in basetype_content["value"].getdimension():
- dimensions.append((dimension.getlower(), dimension.getupper()))
- return tree, dimensions
- elif basetype_content["name"] == "struct":
- for element in basetype_content["value"].getvariable():
- element_type = element.type.getcontent()
- if element_type["name"] == "derived":
- tree.append((element.getname(), element_type["value"].getname(), self.GenerateVarTree(element_type["value"].getname())))
- else:
- tree.append((element.getname(), element_type["name"], ([], [])))
- return tree, []
- return [], []
# Return the interface for the given pou
def GetPouInterfaceVars(self, pou, debug = False):
- vars = []
+ interface = pou.interface
# Verify that the pou has an interface
- if pou.interface is not None:
- # Extract variables from every varLists
- for type, varlist in pou.getvars():
- for var in varlist.getvariable():
- tempvar = self.GetVariableDictionary(varlist, var)
-
- tempvar["Class"] = type
- tempvar["Tree"] = ([], [])
-
- vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- tempvar["Edit"] = not pou.hasblock(tempvar["Name"])
- tempvar["Tree"] = self.GenerateVarTree(tempvar["Type"], debug)
-
- vars.append(tempvar)
- return vars
+ if interface is not None:
+ # Extract variables defined in interface
+ return self.GetVariableDictionary(interface, debug)
+ return []
# Replace the Pou interface by the one given
def SetPouInterfaceVars(self, name, vars):
@@ -1465,46 +1338,40 @@
pou = self.Project.getpou(name)
if pou is not None:
if pou.interface is None:
- pou.interface = plcopen.pou_interface()
+ pou.interface = PLCOpenParser.CreateElement("interface", "pou")
# Set Pou interface
- pou.setvars(self.ExtractVarLists(vars))
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshCustomBlockTypes()
-
+ pou.setvars([varlist for varlist_type, varlist in self.ExtractVarLists(vars)])
+
# Replace the return type of the pou given by its name (only for functions)
- def SetPouInterfaceReturnType(self, name, type):
+ def SetPouInterfaceReturnType(self, name, return_type):
if self.Project is not None:
pou = self.Project.getpou(name)
if pou is not None:
if pou.interface is None:
- pou.interface = plcopen.pou_interface()
+ pou.interface = PLCOpenParser.CreateElement("interface", "pou")
# If there isn't any return type yet, add it
- return_type = pou.interface.getreturnType()
- if not return_type:
- return_type = plcopen.dataType()
- pou.interface.setreturnType(return_type)
+ return_type_obj = pou.interface.getreturnType()
+ if return_type_obj is None:
+ return_type_obj = PLCOpenParser.CreateElement("returnType", "interface")
+ pou.interface.setreturnType(return_type_obj)
# Change return type
- if type in self.GetBaseTypes():
- if type == "STRING":
- return_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif type == "WSTRING":
- return_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
- else:
- return_type.setcontent({"name" : type, "value" : None})
+ if return_type in self.GetBaseTypes():
+ return_type_obj.setcontent(PLCOpenParser.CreateElement(
+ return_type.lower()
+ if return_type in ["STRING", "WSTRING"]
+ else return_type, "dataType"))
else:
- derived_type = plcopen.derivedTypes_derived()
- derived_type.setname(type)
- return_type.setcontent({"name" : "derived", "value" : derived_type})
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshCustomBlockTypes()
-
+ derived_type = PLCOpenParser.CreateElement("derived", "dataType")
+ derived_type.setname(return_type)
+ return_type.setcontent(derived_type)
+
def UpdateProjectUsedPous(self, old_name, new_name):
- if self.Project:
+ if self.Project is not None:
self.Project.updateElementName(old_name, new_name)
def UpdateEditedElementUsedVariable(self, tagname, old_name, new_name):
pou = self.GetEditedElement(tagname)
- if pou:
+ if pou is not None:
pou.updateElementName(old_name, new_name)
# Return the return type of the pou given by its name
@@ -1523,21 +1390,21 @@
if pou.interface is not None:
# Return the return type if there is one
return_type = pou.interface.getreturnType()
- if return_type:
- returntype_content = return_type.getcontent()
- if returntype_content["name"] == "derived":
- return returntype_content["value"].getname()
- elif returntype_content["name"] in ["string", "wstring"]:
- return returntype_content["name"].upper()
- else:
- return returntype_content["name"]
- return None
+ if return_type is not None:
+ return_type_infos_xslt_tree = etree.XSLT(
+ variables_infos_xslt, extensions = {
+ ("var_infos_ns", "var_tree"): VarTree(self)})
+ return [extract_param(el)
+ for el in return_type_infos_xslt_tree(return_type).getroot()]
+
+ return [None, ([], [])]
# Function that add a new confnode to the confnode list
def AddConfNodeTypesList(self, typeslist):
self.ConfNodeTypes.extend(typeslist)
addedcat = [{"name": _("%s POUs") % confnodetypes["name"],
- "list": confnodetypes["types"].GetCustomBlockTypes()}
+ "list": [pou.getblockInfos()
+ for pou in confnodetypes["types"].getpous()]}
for confnodetypes in typeslist]
self.TotalTypes.extend(addedcat)
for cat in addedcat:
@@ -1551,23 +1418,14 @@
self.TotalTypesDict = StdBlckDct.copy()
self.TotalTypes = StdBlckLst[:]
- def GetConfNodeBlockTypes(self):
- return [{"name": _("%s POUs") % confnodetypes["name"],
- "list": confnodetypes["types"].GetCustomBlockTypes()}
- for confnodetypes in self.ConfNodeTypes]
-
def GetConfNodeDataTypes(self, exclude = None, only_locatables = False):
return [{"name": _("%s Data Types") % confnodetypes["name"],
- "list": [datatype["name"] for datatype in confnodetypes["types"].GetCustomDataTypes(exclude, only_locatables)]}
+ "list": [
+ datatype.getname()
+ for datatype in confnodetypes["types"].getdataTypes()
+ if not only_locatables or self.IsLocatableDataType(datatype, debug)]}
for confnodetypes in self.ConfNodeTypes]
- def GetConfNodeDataType(self, typename):
- for confnodetype in self.ConfNodeTypes:
- datatype = confnodetype["types"].getdataType(typename)
- if datatype is not None:
- return datatype
- return None
-
def GetVariableLocationTree(self):
return []
@@ -1577,25 +1435,23 @@
def GetConfigurationExtraVariables(self):
global_vars = []
for var_name, var_type, var_initial in self.GetConfNodeGlobalInstances():
- tempvar = plcopen.varListPlain_variable()
+ tempvar = PLCOpenParser.CreateElement("variable", "globalVars")
tempvar.setname(var_name)
- tempvartype = plcopen.dataType()
+ tempvartype = PLCOpenParser.CreateElement("type", "variable")
if var_type in self.GetBaseTypes():
- if var_type == "STRING":
- tempvartype.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif var_type == "WSTRING":
- tempvartype.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
- else:
- tempvartype.setcontent({"name" : var_type, "value" : None})
+ tempvartype.setcontent(PLCOpenParser.CreateElement(
+ var_type.lower()
+ if var_type in ["STRING", "WSTRING"]
+ else var_type, "dataType"))
else:
- tempderivedtype = plcopen.derivedTypes_derived()
+ tempderivedtype = PLCOpenParser.CreateElement("derived", "dataType")
tempderivedtype.setname(var_type)
- tempvartype.setcontent({"name" : "derived", "value" : tempderivedtype})
+ tempvartype.setcontent(tempderivedtype)
tempvar.settype(tempvartype)
if var_initial != "":
- value = plcopen.value()
+ value = PLCOpenParser.CreateElement("initialValue", "variable")
value.setvalue(var_initial)
tempvar.setinitialValue(value)
@@ -1623,7 +1479,16 @@
return result_blocktype
project = self.GetProject(debug)
if project is not None:
- return project.GetCustomBlockType(typename, inputs)
+ blocktype = project.getpou(typename)
+ if blocktype is not None:
+ blocktype_infos = blocktype.getblockInfos()
+ if inputs in [None, "undefined"]:
+ return blocktype_infos
+
+ if inputs == tuple([var_type
+ for name, var_type, modifier in blocktype_infos["inputs"]]):
+ return blocktype_infos
+
return None
# Return Block types checking for recursion
@@ -1635,39 +1500,41 @@
if project is not None:
pou_type = None
if words[0] in ["P","T","A"]:
- blocktypes = []
name = words[1]
pou_type = self.GetPouType(name, debug)
- if pou_type == "function":
- for category in self.TotalTypes:
- cat = {"name" : category["name"], "list" : []}
- for block in category["list"]:
- if block["type"] == "function":
- cat["list"].append(block)
- if len(cat["list"]) > 0:
- blocktypes.append(cat)
- else:
- blocktypes = [category for category in self.TotalTypes]
+ filter = (["function"]
+ if pou_type == "function" or words[0] == "T"
+ else ["functionBlock", "function"])
+ blocktypes = [
+ {"name": category["name"],
+ "list": [block for block in category["list"]
+ if block["type"] in filter]}
+ for category in self.TotalTypes]
blocktypes.append({"name" : USER_DEFINED_POUS,
- "list": project.GetCustomBlockTypes(name,
- pou_type == "function" or words[0] == "T")})
+ "list": [pou.getblockInfos()
+ for pou in project.getpous(name, filter)
+ if (name is None or
+ self.GetInstanceList(pou, name, debug) is None)]})
return blocktypes
return self.TotalTypes
# Return Function Block types checking for recursion
def GetFunctionBlockTypes(self, tagname = "", debug = False):
+ project = self.GetProject(debug)
+ words = tagname.split("::")
+ name = None
+ if project is not None and words[0] in ["P","T","A"]:
+ name = words[1]
blocktypes = []
for blocks in self.TotalTypesDict.itervalues():
for sectioname,block in blocks:
if block["type"] == "functionBlock":
blocktypes.append(block["name"])
- project = self.GetProject(debug)
- if project is not None:
- name = ""
- words = tagname.split("::")
- if words[0] in ["P","T","A"]:
- name = words[1]
- blocktypes.extend(project.GetCustomFunctionBlockTypes(name))
+ if project is not None:
+ blocktypes.extend([pou.getname()
+ for pou in project.getpous(name, ["functionBlock"])
+ if (name is None or
+ self.GetInstanceList(pou, name, debug) is None)])
return blocktypes
# Return Block types checking for recursion
@@ -1679,7 +1546,9 @@
blocktypes.append(blocktype["name"])
project = self.GetProject(debug)
if project is not None:
- blocktypes.extend(project.GetCustomBlockResource())
+ blocktypes.extend(
+ [pou.getname()
+ for pou in project.getpous(filter=["program"])])
return blocktypes
# Return Data Types checking for recursion
@@ -1694,25 +1563,75 @@
words = tagname.split("::")
if words[0] in ["D"]:
name = words[1]
- datatypes.extend([datatype["name"] for datatype in project.GetCustomDataTypes(name, only_locatables)])
+ datatypes.extend([
+ datatype.getname()
+ for datatype in project.getdataTypes(name)
+ if (not only_locatables or self.IsLocatableDataType(datatype, debug))
+ and (name is None or
+ self.GetInstanceList(datatype, name, debug) is None)])
if confnodetypes:
for category in self.GetConfNodeDataTypes(name, only_locatables):
datatypes.extend(category["list"])
return datatypes
- # Return Base Type of given possible derived type
- def GetBaseType(self, type, debug = False):
- project = self.GetProject(debug)
- if project is not None:
- result = project.GetBaseType(type)
+ # Return Data Type Object
+ def GetPou(self, typename, debug = False):
+ project = self.GetProject(debug)
+ if project is not None:
+ result = project.getpou(typename)
+ if result is not None:
+ return result
+ for standardlibrary in [StdBlockLibrary, AddnlBlockLibrary]:
+ result = standardlibrary.getpou(typename)
if result is not None:
return result
for confnodetype in self.ConfNodeTypes:
- result = confnodetype["types"].GetBaseType(type)
+ result = confnodetype["types"].getpou(typename)
if result is not None:
return result
return None
+
+ # Return Data Type Object
+ def GetDataType(self, typename, debug = False):
+ project = self.GetProject(debug)
+ if project is not None:
+ result = project.getdataType(typename)
+ if result is not None:
+ return result
+ for confnodetype in self.ConfNodeTypes:
+ result = confnodetype["types"].getdataType(typename)
+ if result is not None:
+ return result
+ return None
+
+ # Return Data Type Object Base Type
+ def GetDataTypeBaseType(self, datatype):
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type in ["array", "subrangeSigned", "subrangeUnsigned"]:
+ basetype = basetype_content.baseType.getcontent()
+ basetype_type = basetype.getLocalTag()
+ return (basetype.getname() if basetype_type == "derived"
+ else basetype_type.upper())
+ elif basetype_content_type == "derived":
+ return basetype_content_type.getname()
+ return None
+
+ # Return Base Type of given possible derived type
+ def GetBaseType(self, typename, debug = False):
+ if TypeHierarchy.has_key(typename):
+ return typename
+
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype = self.GetDataTypeBaseType(datatype)
+ if basetype is not None:
+ return self.GetBaseType(basetype, debug)
+ return typename
+
+ return None
+
def GetBaseTypes(self):
'''
return the list of datatypes defined in IEC 61131-3.
@@ -1721,93 +1640,131 @@
'''
return [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]
- def IsOfType(self, type, reference, debug = False):
- if reference is None:
+ def IsOfType(self, typename, reference, debug = False):
+ if reference is None or typename == reference:
return True
- elif type == reference:
- return True
- elif type in TypeHierarchy:
- return self.IsOfType(TypeHierarchy[type], reference)
- else:
- project = self.GetProject(debug)
- if project is not None and project.IsOfType(type, reference):
- return True
- for confnodetype in self.ConfNodeTypes:
- if confnodetype["types"].IsOfType(type, reference):
- return True
+
+ basetype = TypeHierarchy.get(typename)
+ if basetype is not None:
+ return self.IsOfType(basetype, reference)
+
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype = self.GetDataTypeBaseType(datatype)
+ if basetype is not None:
+ return self.IsOfType(basetype, reference, debug)
+
return False
- def IsEndType(self, type):
- if type is not None:
- return not type.startswith("ANY")
+ def IsEndType(self, typename):
+ if typename is not None:
+ return not typename.startswith("ANY")
return True
- def IsLocatableType(self, type, debug = False):
- if isinstance(type, TupleType):
- return False
- if self.GetBlockType(type) is not None:
+ def IsLocatableDataType(self, datatype, debug = False):
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type in ["enum", "struct"]:
return False
- project = self.GetProject(debug)
- if project is not None:
- datatype = project.getdataType(type)
- if datatype is None:
- datatype = self.GetConfNodeDataType(type)
- if datatype is not None:
- return project.IsLocatableType(datatype)
+ elif basetype_content_type == "derived":
+ return self.IsLocatableType(basetype_content.getname())
+ elif basetype_content_type == "array":
+ array_base_type = basetype_content.baseType.getcontent()
+ if array_base_type.getLocalTag() == "derived":
+ return self.IsLocatableType(array_base_type.getname(), debug)
return True
-
- def IsEnumeratedType(self, type, debug = False):
- project = self.GetProject(debug)
- if project is not None:
- datatype = project.getdataType(type)
- if datatype is None:
- datatype = self.GetConfNodeDataType(type)
- if datatype is not None:
- basetype_content = datatype.baseType.getcontent()
- return basetype_content["name"] == "enum"
+
+ def IsLocatableType(self, typename, debug = False):
+ if isinstance(typename, TupleType) or self.GetBlockType(typename) is not None:
+ return False
+
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ return self.IsLocatableDataType(datatype)
+ return True
+
+ def IsEnumeratedType(self, typename, debug = False):
+ if isinstance(typename, TupleType):
+ typename = typename[1]
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type == "derived":
+ return self.IsEnumeratedType(basetype_content_type, debug)
+ return basetype_content_type == "enum"
return False
- def IsNumType(self, type, debug = False):
- return self.IsOfType(type, "ANY_NUM", debug) or\
- self.IsOfType(type, "ANY_BIT", debug)
+ def IsSubrangeType(self, typename, exclude=None, debug = False):
+ if typename == exclude:
+ return False
+ if isinstance(typename, TupleType):
+ typename = typename[1]
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type == "derived":
+ return self.IsSubrangeType(basetype_content_type, exclude, debug)
+ elif basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
+ return not self.IsOfType(
+ self.GetDataTypeBaseType(datatype), exclude)
+ return False
+
+ def IsNumType(self, typename, debug = False):
+ return self.IsOfType(typename, "ANY_NUM", debug) or\
+ self.IsOfType(typename, "ANY_BIT", debug)
- def GetDataTypeRange(self, type, debug = False):
- if type in DataTypeRange:
- return DataTypeRange[type]
+ def GetDataTypeRange(self, typename, debug = False):
+ range = DataTypeRange.get(typename)
+ if range is not None:
+ return range
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
+ return (basetype_content.range.getlower(),
+ basetype_content.range.getupper())
+ elif basetype_content_type == "derived":
+ return self.GetDataTypeRange(basetype_content.getname(), debug)
+ return None
+
+ # Return Subrange types
+ def GetSubrangeBaseTypes(self, exclude, debug = False):
+ subrange_basetypes = DataTypeRange.keys()
+ project = self.GetProject(debug)
+ if project is not None:
+ subrange_basetypes.extend(
+ [datatype.getname() for datatype in project.getdataTypes()
+ if self.IsSubrangeType(datatype.getname(), exclude, debug)])
+ for confnodetype in self.ConfNodeTypes:
+ subrange_basetypes.extend(
+ [datatype.getname() for datatype in confnodetype["types"].getdataTypes()
+ if self.IsSubrangeType(datatype.getname(), exclude, debug)])
+ return subrange_basetypes
+
+ # Return Enumerated Values
+ def GetEnumeratedDataValues(self, typename = None, debug = False):
+ values = []
+ if typename is not None:
+ datatype_obj = self.GetDataType(typename, debug)
+ if datatype_obj is not None:
+ basetype_content = datatype_obj.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type == "enum":
+ return [value.getname()
+ for value in basetype_content.xpath(
+ "ppx:values/ppx:value",
+ namespaces=PLCOpenParser.NSMAP)]
+ elif basetype_content_type == "derived":
+ return self.GetEnumeratedDataValues(basetype_content.getname(), debug)
else:
project = self.GetProject(debug)
if project is not None:
- result = project.GetDataTypeRange(type)
- if result is not None:
- return result
+ values.extend(project.GetEnumeratedDataTypeValues())
for confnodetype in self.ConfNodeTypes:
- result = confnodetype["types"].GetDataTypeRange(type)
- if result is not None:
- return result
- return None
-
- # Return Subrange types
- def GetSubrangeBaseTypes(self, exclude, debug = False):
- subrange_basetypes = []
- project = self.GetProject(debug)
- if project is not None:
- subrange_basetypes.extend(project.GetSubrangeBaseTypes(exclude))
- for confnodetype in self.ConfNodeTypes:
- subrange_basetypes.extend(confnodetype["types"].GetSubrangeBaseTypes(exclude))
- return DataTypeRange.keys() + subrange_basetypes
-
- # Return Enumerated Values
- def GetEnumeratedDataValues(self, type = None, debug = False):
- values = []
- project = self.GetProject(debug)
- if project is not None:
- values.extend(project.GetEnumeratedDataTypeValues(type))
- if type is None and len(values) > 0:
- return values
- for confnodetype in self.ConfNodeTypes:
- values.extend(confnodetype["types"].GetEnumeratedDataTypeValues(type))
- if type is None and len(values) > 0:
- return values
+ values.extend(confnodetype["types"].GetEnumeratedDataTypeValues())
return values
#-------------------------------------------------------------------------------
@@ -1859,62 +1816,64 @@
if datatype is None:
return None
basetype_content = datatype.baseType.getcontent()
- if basetype_content["value"] is None or basetype_content["name"] in ["string", "wstring"]:
- infos["type"] = "Directly"
- infos["base_type"] = basetype_content["name"].upper()
- elif basetype_content["name"] == "derived":
- infos["type"] = "Directly"
- infos["base_type"] = basetype_content["value"].getname()
- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
infos["type"] = "Subrange"
- infos["min"] = basetype_content["value"].range.getlower()
- infos["max"] = basetype_content["value"].range.getupper()
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["value"] is None:
- infos["base_type"] = base_type["name"]
- else:
- infos["base_type"] = base_type["value"].getname()
- elif basetype_content["name"] == "enum":
+ infos["min"] = basetype_content.range.getlower()
+ infos["max"] = basetype_content.range.getupper()
+ base_type = basetype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
+ infos["base_type"] = (base_type.getname()
+ if base_type_type == "derived"
+ else base_type_type)
+ elif basetype_content_type == "enum":
infos["type"] = "Enumerated"
infos["values"] = []
- for value in basetype_content["value"].values.getvalue():
+ for value in basetype_content.xpath("ppx:values/ppx:value", namespaces=PLCOpenParser.NSMAP):
infos["values"].append(value.getname())
- elif basetype_content["name"] == "array":
+ elif basetype_content_type == "array":
infos["type"] = "Array"
infos["dimensions"] = []
- for dimension in basetype_content["value"].getdimension():
+ for dimension in basetype_content.getdimension():
infos["dimensions"].append((dimension.getlower(), dimension.getupper()))
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
- infos["base_type"] = base_type["name"].upper()
- else:
- infos["base_type"] = base_type["value"].getname()
- elif basetype_content["name"] == "struct":
+ base_type = basetype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
+ infos["base_type"] = (base_type.getname()
+ if base_type_type == "derived"
+ else base_type_type.upper())
+ elif basetype_content_type == "struct":
infos["type"] = "Structure"
infos["elements"] = []
- for element in basetype_content["value"].getvariable():
+ for element in basetype_content.getvariable():
element_infos = {}
element_infos["Name"] = element.getname()
element_type = element.type.getcontent()
- if element_type["value"] is None or element_type["name"] in ["string", "wstring"]:
- element_infos["Type"] = element_type["name"].upper()
- elif element_type["name"] == "array":
+ element_type_type = element_type.getLocalTag()
+ if element_type_type == "array":
dimensions = []
- for dimension in element_type["value"].getdimension():
+ for dimension in element_type.getdimension():
dimensions.append((dimension.getlower(), dimension.getupper()))
- base_type = element_type["value"].baseType.getcontent()
- if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
- base_type_name = base_type["name"].upper()
- else:
- base_type_name = base_type["value"].getname()
- element_infos["Type"] = ("array", base_type_name, dimensions)
+ base_type = element_type.baseType.getcontent()
+ base_type_type = element_type.getLocalTag()
+ element_infos["Type"] = ("array",
+ base_type.getname()
+ if base_type_type == "derived"
+ else base_type_type.upper(), dimensions)
+ elif element_type_type == "derived":
+ element_infos["Type"] = element_type.getname()
else:
- element_infos["Type"] = element_type["value"].getname()
+ element_infos["Type"] = element_type_type.upper()
if element.initialValue is not None:
element_infos["Initial Value"] = str(element.initialValue.getvalue())
else:
element_infos["Initial Value"] = ""
infos["elements"].append(element_infos)
+ else:
+ infos["type"] = "Directly"
+ infos["base_type"] = (basetype_content.getname()
+ if basetype_content_type == "derived"
+ else basetype_content_type.upper())
+
if datatype.initialValue is not None:
infos["initial"] = str(datatype.initialValue.getvalue())
else:
@@ -1929,45 +1888,46 @@
datatype = self.Project.getdataType(words[1])
if infos["type"] == "Directly":
if infos["base_type"] in self.GetBaseTypes():
- if infos["base_type"] == "STRING":
- datatype.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif infos["base_type"] == "WSTRING":
- datatype.baseType.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
- else:
- datatype.baseType.setcontent({"name" : infos["base_type"], "value" : None})
+ datatype.baseType.setcontent(PLCOpenParser.CreateElement(
+ infos["base_type"].lower()
+ if infos["base_type"] in ["STRING", "WSTRING"]
+ else infos["base_type"], "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(infos["base_type"])
- datatype.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
+ datatype.baseType.setcontent(derived_datatype)
elif infos["type"] == "Subrange":
- if infos["base_type"] in GetSubTypes("ANY_UINT"):
- subrange = plcopen.derivedTypes_subrangeUnsigned()
- datatype.baseType.setcontent({"name" : "subrangeUnsigned", "value" : subrange})
- else:
- subrange = plcopen.derivedTypes_subrangeSigned()
- datatype.baseType.setcontent({"name" : "subrangeSigned", "value" : subrange})
+ subrange = PLCOpenParser.CreateElement(
+ "subrangeUnsigned"
+ if infos["base_type"] in GetSubTypes("ANY_UINT")
+ else "subrangeSigned", "dataType")
+ datatype.baseType.setcontent(subrange)
subrange.range.setlower(infos["min"])
subrange.range.setupper(infos["max"])
if infos["base_type"] in self.GetBaseTypes():
- subrange.baseType.setcontent({"name" : infos["base_type"], "value" : None})
+ subrange.baseType.setcontent(
+ PLCOpenParser.CreateElement(infos["base_type"], "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(infos["base_type"])
- subrange.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
+ subrange.baseType.setcontent(derived_datatype)
elif infos["type"] == "Enumerated":
- enumerated = plcopen.derivedTypes_enum()
+ enumerated = PLCOpenParser.CreateElement("enum", "dataType")
+ datatype.baseType.setcontent(enumerated)
+ values = PLCOpenParser.CreateElement("values", "enum")
+ enumerated.setvalues(values)
for i, enum_value in enumerate(infos["values"]):
- value = plcopen.values_value()
+ value = PLCOpenParser.CreateElement("value", "values")
value.setname(enum_value)
if i == 0:
- enumerated.values.setvalue([value])
+ values.setvalue([value])
else:
- enumerated.values.appendvalue(value)
- datatype.baseType.setcontent({"name" : "enum", "value" : enumerated})
+ values.appendvalue(value)
elif infos["type"] == "Array":
- array = plcopen.derivedTypes_array()
+ array = PLCOpenParser.CreateElement("array", "dataType")
+ datatype.baseType.setcontent(array)
for i, dimension in enumerate(infos["dimensions"]):
- dimension_range = plcopen.rangeSigned()
+ dimension_range = PLCOpenParser.CreateElement("dimension", "array")
dimension_range.setlower(dimension[0])
dimension_range.setupper(dimension[1])
if i == 0:
@@ -1975,28 +1935,28 @@
else:
array.appenddimension(dimension_range)
if infos["base_type"] in self.GetBaseTypes():
- if infos["base_type"] == "STRING":
- array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif infos["base_type"] == "WSTRING":
- array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
- else:
- array.baseType.setcontent({"name" : infos["base_type"], "value" : None})
+ array.baseType.setcontent(PLCOpenParser.CreateElement(
+ infos["base_type"].lower()
+ if infos["base_type"] in ["STRING", "WSTRING"]
+ else infos["base_type"], "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(infos["base_type"])
- array.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
- datatype.baseType.setcontent({"name" : "array", "value" : array})
+ array.baseType.setcontent(derived_datatype)
elif infos["type"] == "Structure":
- struct = plcopen.varListPlain()
+ struct = PLCOpenParser.CreateElement("struct", "dataType")
+ datatype.baseType.setcontent(struct)
for i, element_infos in enumerate(infos["elements"]):
- element = plcopen.varListPlain_variable()
+ element = PLCOpenParser.CreateElement("variable", "struct")
element.setname(element_infos["Name"])
+ element_type = PLCOpenParser.CreateElement("type", "variable")
if isinstance(element_infos["Type"], TupleType):
if element_infos["Type"][0] == "array":
array_type, base_type_name, dimensions = element_infos["Type"]
- array = plcopen.derivedTypes_array()
+ array = PLCOpenParser.CreateElement("array", "dataType")
+ element_type.setcontent(array)
for j, dimension in enumerate(dimensions):
- dimension_range = plcopen.rangeSigned()
+ dimension_range = PLCOpenParser.CreateElement("dimension", "array")
dimension_range.setlower(dimension[0])
dimension_range.setupper(dimension[1])
if j == 0:
@@ -2004,45 +1964,39 @@
else:
array.appenddimension(dimension_range)
if base_type_name in self.GetBaseTypes():
- if base_type_name == "STRING":
- array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif base_type_name == "WSTRING":
- array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
- else:
- array.baseType.setcontent({"name" : base_type_name, "value" : None})
+ array.baseType.setcontent(PLCOpenParser.CreateElement(
+ base_type_name.lower()
+ if base_type_name in ["STRING", "WSTRING"]
+ else base_type_name, "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(base_type_name)
- array.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
- element.type.setcontent({"name" : "array", "value" : array})
+ array.baseType.setcontent(derived_datatype)
elif element_infos["Type"] in self.GetBaseTypes():
- if element_infos["Type"] == "STRING":
- element.type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif element_infos["Type"] == "WSTRING":
- element.type.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
- else:
- element.type.setcontent({"name" : element_infos["Type"], "value" : None})
+ element_type.setcontent(
+ PLCOpenParser.CreateElement(
+ element_infos["Type"].lower()
+ if element_infos["Type"] in ["STRING", "WSTRING"]
+ else element_infos["Type"], "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(element_infos["Type"])
- element.type.setcontent({"name" : "derived", "value" : derived_datatype})
+ element_type.setcontent(derived_datatype)
+ element.settype(element_type)
if element_infos["Initial Value"] != "":
- value = plcopen.value()
+ value = PLCOpenParser.CreateElement("initialValue", "variable")
value.setvalue(element_infos["Initial Value"])
element.setinitialValue(value)
if i == 0:
struct.setvariable([element])
else:
struct.appendvariable(element)
- datatype.baseType.setcontent({"name" : "struct", "value" : struct})
if infos["initial"] != "":
if datatype.initialValue is None:
- datatype.initialValue = plcopen.value()
+ datatype.initialValue = PLCOpenParser.CreateElement("initialValue", "dataType")
datatype.initialValue.setvalue(infos["initial"])
else:
datatype.initialValue = None
- self.Project.RefreshDataTypeHierarchy()
- self.Project.RefreshElementUsingTree()
self.BufferProject()
#-------------------------------------------------------------------------------
@@ -2128,7 +2082,6 @@
element = self.GetEditedElement(tagname)
if element is not None:
element.settext(text)
- self.Project.RefreshElementUsingTree()
# Return the edited element text
def GetEditedElementText(self, tagname, debug = False):
@@ -2173,22 +2126,28 @@
def GetEditedElementCopy(self, tagname, debug = False):
element = self.GetEditedElement(tagname, debug)
if element is not None:
- name = element.__class__.__name__
- return element.generateXMLText(name.split("_")[-1], 0)
+ return element.tostring()
return ""
def GetEditedElementInstancesCopy(self, tagname, blocks_id = None, wires = None, debug = False):
element = self.GetEditedElement(tagname, debug)
text = ""
if element is not None:
- wires = dict([(wire, True) for wire in wires if wire[0] in blocks_id and wire[1] in blocks_id])
+ wires = dict([(wire, True)
+ for wire in wires
+ if wire[0] in blocks_id and wire[1] in blocks_id])
+ copy_body = PLCOpenParser.CreateElement("body", "pou")
+ element.append(copy_body)
+ copy_body.setcontent(
+ PLCOpenParser.CreateElement(element.getbodyType(), "body"))
for id in blocks_id:
instance = element.getinstance(id)
if instance is not None:
- instance_copy = self.Copy(instance)
+ copy_body.appendcontentInstance(self.Copy(instance))
+ instance_copy = copy_body.getcontentInstance(id)
instance_copy.filterConnections(wires)
- name = instance_copy.__class__.__name__
- text += instance_copy.generateXMLText(name.split("_")[-1], 0)
+ text += instance_copy.tostring()
+ element.remove(copy_body)
return text
def GenerateNewName(self, tagname, name, format, start_idx=0, exclude={}, debug=False):
@@ -2201,9 +2160,10 @@
element = self.GetEditedElement(tagname, debug)
if element is not None and element.getbodyType() not in ["ST", "IL"]:
for instance in element.getinstances():
- if isinstance(instance, (plcopen.sfcObjects_step,
- plcopen.commonObjects_connector,
- plcopen.commonObjects_continuation)):
+ if isinstance(instance,
+ (PLCOpenParser.GetElementClass("step", "sfcObjects"),
+ PLCOpenParser.GetElementClass("connector", "commonObjects"),
+ PLCOpenParser.GetElementClass("continuation", "commonObjects"))):
names[instance.getname().upper()] = True
else:
project = self.GetProject(debug)
@@ -2229,10 +2189,6 @@
i += 1
return name
- CheckPasteCompatibility = {"SFC": lambda name: True,
- "LD": lambda name: not name.startswith("sfcObjects"),
- "FBD": lambda name: name.startswith("fbdObjects") or name.startswith("commonObjects")}
-
def PasteEditedElementInstances(self, tagname, text, new_pos, middle=False, debug=False):
element = self.GetEditedElement(tagname, debug)
element_name, element_type = self.GetEditedElementType(tagname, debug)
@@ -2250,62 +2206,46 @@
used_id = dict([(instance.getlocalId(), True) for instance in element.getinstances()])
new_id = {}
- text = "<paste>%s</paste>"%text
-
try:
- tree = minidom.parseString(text.encode("utf-8"))
+ instances = LoadPouInstances(text.encode("utf-8"), bodytype)
+ if len(instances) == 0:
+ raise ValueError
except:
return _("Invalid plcopen element(s)!!!")
- instances = []
+
exclude = {}
- for root in tree.childNodes:
- if root.nodeType == tree.ELEMENT_NODE and root.nodeName == "paste":
- for child in root.childNodes:
- if child.nodeType == tree.ELEMENT_NODE:
- if not child.nodeName in plcopen.ElementNameToClass:
- return _("\"%s\" element can't be pasted here!!!")%child.nodeName
-
- classname = plcopen.ElementNameToClass[child.nodeName]
- if not self.CheckPasteCompatibility[bodytype](classname):
- return _("\"%s\" element can't be pasted here!!!")%child.nodeName
-
- classobj = getattr(plcopen, classname, None)
- if classobj is not None:
- instance = classobj()
- instance.loadXMLTree(child)
- if child.nodeName == "block":
- blockname = instance.getinstanceName()
- if blockname is not None:
- blocktype = instance.gettypeName()
- if element_type == "function":
- return _("FunctionBlock \"%s\" can't be pasted in a Function!!!")%blocktype
- blockname = self.GenerateNewName(tagname,
- blockname,
- "%s%%d"%blocktype,
- debug=debug)
- exclude[blockname] = True
- instance.setinstanceName(blockname)
- self.AddEditedElementPouVar(tagname, blocktype, blockname)
- elif child.nodeName == "step":
- stepname = self.GenerateNewName(tagname,
- instance.getname(),
- "Step%d",
- exclude=exclude,
- debug=debug)
- exclude[stepname] = True
- instance.setname(stepname)
- localid = instance.getlocalId()
- if not used_id.has_key(localid):
- new_id[localid] = True
- instances.append((child.nodeName, instance))
-
- if len(instances) == 0:
- return _("Invalid plcopen element(s)!!!")
+ for instance in instances:
+ element.addinstance(instance)
+ instance_type = instance.getLocalTag()
+ if instance_type == "block":
+ blockname = instance.getinstanceName()
+ if blockname is not None:
+ blocktype = instance.gettypeName()
+ if element_type == "function":
+ return _("FunctionBlock \"%s\" can't be pasted in a Function!!!")%blocktype
+ blockname = self.GenerateNewName(tagname,
+ blockname,
+ "%s%%d"%blocktype,
+ debug=debug)
+ exclude[blockname] = True
+ instance.setinstanceName(blockname)
+ self.AddEditedElementPouVar(tagname, blocktype, blockname)
+ elif instance_type == "step":
+ stepname = self.GenerateNewName(tagname,
+ instance.getname(),
+ "Step%d",
+ exclude=exclude,
+ debug=debug)
+ exclude[stepname] = True
+ instance.setname(stepname)
+ localid = instance.getlocalId()
+ if not used_id.has_key(localid):
+ new_id[localid] = True
idx = 1
translate_id = {}
- bbox = plcopen.rect()
- for name, instance in instances:
+ bbox = rect()
+ for instance in instances:
localId = instance.getlocalId()
bbox.union(instance.getBoundingBox())
if used_id.has_key(localId):
@@ -2338,12 +2278,11 @@
diff = (new_pos[0] - x, new_pos[1] - y)
connections = {}
- for name, instance in instances:
+ for instance in instances:
connections.update(instance.updateConnectionsId(translate_id))
if getattr(instance, "setexecutionOrderId", None) is not None:
instance.setexecutionOrderId(0)
instance.translate(*diff)
- element.addinstance(name, instance)
return new_id, connections
@@ -2387,17 +2326,16 @@
if words[0] == "T" and varname == words[2]:
return "BOOL"
if words[1] == varname:
- return self.GetPouInterfaceReturnType(pou)
+ return self.GetPouInterfaceReturnType(pou)[0]
for type, varlist in pou.getvars():
for var in varlist.getvariable():
if var.getname() == varname:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- return vartype_content["value"].getname()
- elif vartype_content["name"] in ["string", "wstring"]:
- return vartype_content["name"].upper()
+ vartype_content_type = vartype_content.getLocalTag()
+ if vartype_content_type == "derived":
+ return vartype_content.getname()
else:
- return vartype_content["name"]
+ return vartype_content_type.upper()
return None
def SetConnectionWires(self, connection, connector):
@@ -2422,21 +2360,36 @@
connection.setconnectionParameter(idx, None)
idx += 1
- def AddEditedElementPouVar(self, tagname, type, name, location="", description=""):
+ def GetVarTypeObject(self, var_type):
+ var_type_obj = PLCOpenParser.CreateElement("type", "variable")
+ if not var_type.startswith("ANY") and TypeHierarchy.get(var_type):
+ var_type_obj.setcontent(PLCOpenParser.CreateElement(
+ var_type.lower() if var_type in ["STRING", "WSTRING"]
+ else var_type, "dataType"))
+ else:
+ derived_type = PLCOpenParser.CreateElement("derived", "dataType")
+ derived_type.setname(var_type)
+ var_type_obj.setcontent(derived_type)
+ return var_type_obj
+
+ def AddEditedElementPouVar(self, tagname, var_type, name, location="", description=""):
if self.Project is not None:
words = tagname.split("::")
if words[0] in ['P', 'T', 'A']:
pou = self.Project.getpou(words[1])
if pou is not None:
- pou.addpouLocalVar(type, name, location, description)
-
- def AddEditedElementPouExternalVar(self, tagname, type, name):
+ pou.addpouLocalVar(
+ self.GetVarTypeObject(var_type),
+ name, location, description)
+
+ def AddEditedElementPouExternalVar(self, tagname, var_type, name):
if self.Project is not None:
words = tagname.split("::")
if words[0] in ['P', 'T', 'A']:
pou = self.Project.getpou(words[1])
if pou is not None:
- pou.addpouExternalVar(type, name)
+ pou.addpouExternalVar(
+ self.GetVarTypeObject(var_type), name)
def ChangeEditedElementPouVar(self, tagname, old_type, old_name, new_type, new_name):
if self.Project is not None:
@@ -2457,15 +2410,14 @@
def AddEditedElementBlock(self, tagname, id, blocktype, blockname = None):
element = self.GetEditedElement(tagname)
if element is not None:
- block = plcopen.fbdObjects_block()
+ block = PLCOpenParser.CreateElement("block", "fbdObjects")
block.setlocalId(id)
block.settypeName(blocktype)
blocktype_infos = self.GetBlockType(blocktype)
if blocktype_infos["type"] != "function" and blockname is not None:
block.setinstanceName(blockname)
self.AddEditedElementPouVar(tagname, blocktype, blockname)
- element.addinstance("block", block)
- self.Project.RefreshElementUsingTree()
+ element.addinstance(block)
def SetEditedElementBlockInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2510,7 +2462,8 @@
block.inputVariables.setvariable([])
block.outputVariables.setvariable([])
for connector in value["inputs"]:
- variable = plcopen.inputVariables_variable()
+ variable = PLCOpenParser.CreateElement("variable", "inputVariables")
+ block.inputVariables.appendvariable(variable)
variable.setformalParameter(connector.GetName())
if connector.IsNegated():
variable.setnegated(True)
@@ -2519,9 +2472,9 @@
position = connector.GetRelPosition()
variable.connectionPointIn.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(variable.connectionPointIn, connector)
- block.inputVariables.appendvariable(variable)
for connector in value["outputs"]:
- variable = plcopen.outputVariables_variable()
+ variable = PLCOpenParser.CreateElement("variable", "outputVariables")
+ block.outputVariables.appendvariable(variable)
variable.setformalParameter(connector.GetName())
if connector.IsNegated():
variable.setnegated(True)
@@ -2530,23 +2483,17 @@
position = connector.GetRelPosition()
variable.addconnectionPointOut()
variable.connectionPointOut.setrelPositionXY(position.x, position.y)
- block.outputVariables.appendvariable(variable)
- self.Project.RefreshElementUsingTree()
-
- def AddEditedElementVariable(self, tagname, id, type):
+ block.tostring()
+
+ def AddEditedElementVariable(self, tagname, id, var_type):
element = self.GetEditedElement(tagname)
- if element is not None:
- if type == INPUT:
- name = "inVariable"
- variable = plcopen.fbdObjects_inVariable()
- elif type == OUTPUT:
- name = "outVariable"
- variable = plcopen.fbdObjects_outVariable()
- elif type == INOUT:
- name = "inOutVariable"
- variable = plcopen.fbdObjects_inOutVariable()
+ if element is not None:
+ variable = PLCOpenParser.CreateElement(
+ {INPUT: "inVariable",
+ OUTPUT: "outVariable",
+ INOUT: "inOutVariable"}[var_type], "fbdObjects")
variable.setlocalId(id)
- element.addinstance(name, variable)
+ element.addinstance(variable)
def SetEditedElementVariableInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2556,7 +2503,7 @@
return
for param, value in infos.items():
if param == "name":
- variable.setexpression(value)
+ variable.setexpression(value)
elif param == "executionOrder" and variable.getexecutionOrderId() != value:
element.setelementExecutionOrder(variable, value)
elif param == "height":
@@ -2592,17 +2539,14 @@
variable.connectionPointIn.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(variable.connectionPointIn, input)
- def AddEditedElementConnection(self, tagname, id, type):
+ def AddEditedElementConnection(self, tagname, id, connection_type):
element = self.GetEditedElement(tagname)
if element is not None:
- if type == CONNECTOR:
- name = "connector"
- connection = plcopen.commonObjects_connector()
- elif type == CONTINUATION:
- name = "continuation"
- connection = plcopen.commonObjects_continuation()
+ connection = PLCOpenParser.CreateElement(
+ {CONNECTOR: "connector",
+ CONTINUATION: "continuation"}[connection_type], "commonObjects")
connection.setlocalId(id)
- element.addinstance(name, connection)
+ element.addinstance(connection)
def SetEditedElementConnectionInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2623,10 +2567,10 @@
connection.sety(value)
elif param == "connector":
position = value.GetRelPosition()
- if isinstance(connection, plcopen.commonObjects_continuation):
+ if isinstance(connection, PLCOpenParser.GetElementClass("continuation", "commonObjects")):
connection.addconnectionPointOut()
connection.connectionPointOut.setrelPositionXY(position.x, position.y)
- elif isinstance(connection, plcopen.commonObjects_connector):
+ elif isinstance(connection, PLCOpenParser.GetElementClass("connector", "commonObjects")):
connection.addconnectionPointIn()
connection.connectionPointIn.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(connection.connectionPointIn, value)
@@ -2634,9 +2578,9 @@
def AddEditedElementComment(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- comment = plcopen.commonObjects_comment()
+ comment = PLCOpenParser.CreateElement("comment", "commonObjects")
comment.setlocalId(id)
- element.addinstance("comment", comment)
+ element.addinstance(comment)
def SetEditedElementCommentInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2654,17 +2598,14 @@
elif param == "y":
comment.sety(value)
- def AddEditedElementPowerRail(self, tagname, id, type):
+ def AddEditedElementPowerRail(self, tagname, id, powerrail_type):
element = self.GetEditedElement(tagname)
if element is not None:
- if type == LEFTRAIL:
- name = "leftPowerRail"
- powerrail = plcopen.ldObjects_leftPowerRail()
- elif type == RIGHTRAIL:
- name = "rightPowerRail"
- powerrail = plcopen.ldObjects_rightPowerRail()
+ powerrail = PLCOpenParser.CreateElement(
+ {LEFTRAIL: "leftPowerRail",
+ RIGHTRAIL: "rightPowerRail"}[powerrail_type], "ldObjects")
powerrail.setlocalId(id)
- element.addinstance(name, powerrail)
+ element.addinstance(powerrail)
def SetEditedElementPowerRailInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2682,28 +2623,28 @@
elif param == "y":
powerrail.sety(value)
elif param == "connectors":
- if isinstance(powerrail, plcopen.ldObjects_leftPowerRail):
+ if isinstance(powerrail, PLCOpenParser.GetElementClass("leftPowerRail", "ldObjects")):
powerrail.setconnectionPointOut([])
for connector in value["outputs"]:
position = connector.GetRelPosition()
- connection = plcopen.leftPowerRail_connectionPointOut()
+ connection = PLCOpenParser.CreateElement("connectionPointOut", "leftPowerRail")
+ powerrail.appendconnectionPointOut(connection)
connection.setrelPositionXY(position.x, position.y)
- powerrail.connectionPointOut.append(connection)
- elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail):
+ elif isinstance(powerrail, PLCOpenParser.GetElementClass("rightPowerRail", "ldObjects")):
powerrail.setconnectionPointIn([])
for connector in value["inputs"]:
position = connector.GetRelPosition()
- connection = plcopen.connectionPointIn()
+ connection = PLCOpenParser.CreateElement("connectionPointIn", "rightPowerRail")
+ powerrail.appendconnectionPointIn(connection)
connection.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(connection, connector)
- powerrail.connectionPointIn.append(connection)
-
+
def AddEditedElementContact(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- contact = plcopen.ldObjects_contact()
+ contact = PLCOpenParser.CreateElement("contact", "ldObjects")
contact.setlocalId(id)
- element.addinstance("contact", contact)
+ element.addinstance(contact)
def SetEditedElementContactInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2715,18 +2656,13 @@
if param == "name":
contact.setvariable(value)
elif param == "type":
- if value == CONTACT_NORMAL:
- contact.setnegated(False)
- contact.setedge("none")
- elif value == CONTACT_REVERSE:
- contact.setnegated(True)
- contact.setedge("none")
- elif value == CONTACT_RISING:
- contact.setnegated(False)
- contact.setedge("rising")
- elif value == CONTACT_FALLING:
- contact.setnegated(False)
- contact.setedge("falling")
+ negated, edge = {
+ CONTACT_NORMAL: (False, "none"),
+ CONTACT_REVERSE: (True, "none"),
+ CONTACT_RISING: (False, "rising"),
+ CONTACT_FALLING: (False, "falling")}[value]
+ contact.setnegated(negated)
+ contact.setedge(edge)
elif param == "height":
contact.setheight(value)
elif param == "width":
@@ -2749,9 +2685,9 @@
def AddEditedElementCoil(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- coil = plcopen.ldObjects_coil()
+ coil = PLCOpenParser.CreateElement("coil", "ldObjects")
coil.setlocalId(id)
- element.addinstance("coil", coil)
+ element.addinstance(coil)
def SetEditedElementCoilInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2763,30 +2699,16 @@
if param == "name":
coil.setvariable(value)
elif param == "type":
- if value == COIL_NORMAL:
- coil.setnegated(False)
- coil.setstorage("none")
- coil.setedge("none")
- elif value == COIL_REVERSE:
- coil.setnegated(True)
- coil.setstorage("none")
- coil.setedge("none")
- elif value == COIL_SET:
- coil.setnegated(False)
- coil.setstorage("set")
- coil.setedge("none")
- elif value == COIL_RESET:
- coil.setnegated(False)
- coil.setstorage("reset")
- coil.setedge("none")
- elif value == COIL_RISING:
- coil.setnegated(False)
- coil.setstorage("none")
- coil.setedge("rising")
- elif value == COIL_FALLING:
- coil.setnegated(False)
- coil.setstorage("none")
- coil.setedge("falling")
+ negated, storage, edge = {
+ COIL_NORMAL: (False, "none", "none"),
+ COIL_REVERSE: (True, "none", "none"),
+ COIL_SET: (False, "set", "none"),
+ COIL_RESET: (False, "reset", "none"),
+ COIL_RISING: (False, "none", "rising"),
+ COIL_FALLING: (False, "none", "falling")}[value]
+ coil.setnegated(negated)
+ coil.setstorage(storage)
+ coil.setedge(edge)
elif param == "height":
coil.setheight(value)
elif param == "width":
@@ -2809,9 +2731,9 @@
def AddEditedElementStep(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- step = plcopen.sfcObjects_step()
+ step = PLCOpenParser.CreateElement("step", "sfcObjects")
step.setlocalId(id)
- element.addinstance("step", step)
+ element.addinstance(step)
def SetEditedElementStepInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2859,9 +2781,9 @@
def AddEditedElementTransition(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- transition = plcopen.sfcObjects_transition()
+ transition = PLCOpenParser.CreateElement("transition", "sfcObjects")
transition.setlocalId(id)
- element.addinstance("transition", transition)
+ element.addinstance(transition)
def SetEditedElementTransitionInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2897,25 +2819,31 @@
transition.connectionPointOut.setrelPositionXY(position.x, position.y)
elif infos.get("type", None) == "connection" and param == "connection" and value:
transition.setconditionContent("connection", None)
- self.SetConnectionWires(transition.condition.content["value"], value)
-
- def AddEditedElementDivergence(self, tagname, id, type):
+ self.SetConnectionWires(transition.condition.content, value)
+
+ def AddEditedElementDivergence(self, tagname, id, divergence_type):
element = self.GetEditedElement(tagname)
if element is not None:
- if type == SELECTION_DIVERGENCE:
- name = "selectionDivergence"
- divergence = plcopen.sfcObjects_selectionDivergence()
- elif type == SELECTION_CONVERGENCE:
- name = "selectionConvergence"
- divergence = plcopen.sfcObjects_selectionConvergence()
- elif type == SIMULTANEOUS_DIVERGENCE:
- name = "simultaneousDivergence"
- divergence = plcopen.sfcObjects_simultaneousDivergence()
- elif type == SIMULTANEOUS_CONVERGENCE:
- name = "simultaneousConvergence"
- divergence = plcopen.sfcObjects_simultaneousConvergence()
+ divergence = PLCOpenParser.CreateElement(
+ {SELECTION_DIVERGENCE: "selectionDivergence",
+ SELECTION_CONVERGENCE: "selectionConvergence",
+ SIMULTANEOUS_DIVERGENCE: "simultaneousDivergence",
+ SIMULTANEOUS_CONVERGENCE: "simultaneousConvergence"}.get(
+ divergence_type), "sfcObjects")
divergence.setlocalId(id)
- element.addinstance(name, divergence)
+ element.addinstance(divergence)
+
+ DivergenceTypes = [
+ (divergence_type,
+ PLCOpenParser.GetElementClass(divergence_type, "sfcObjects"))
+ for divergence_type in ["selectionDivergence", "simultaneousDivergence",
+ "selectionConvergence", "simultaneousConvergence"]]
+
+ def GetDivergenceType(self, divergence):
+ for divergence_type, divergence_class in self.DivergenceTypes:
+ if isinstance(divergence, divergence_class):
+ return divergence_type
+ return None
def SetEditedElementDivergenceInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2934,7 +2862,8 @@
divergence.sety(value)
elif param == "connectors":
input_connectors = value["inputs"]
- if isinstance(divergence, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)):
+ divergence_type = self.GetDivergenceType(divergence)
+ if divergence_type in ["selectionDivergence", "simultaneousDivergence"]:
position = input_connectors[0].GetRelPosition()
divergence.addconnectionPointIn()
divergence.connectionPointIn.setrelPositionXY(position.x, position.y)
@@ -2943,15 +2872,12 @@
divergence.setconnectionPointIn([])
for input_connector in input_connectors:
position = input_connector.GetRelPosition()
- if isinstance(divergence, plcopen.sfcObjects_selectionConvergence):
- connection = plcopen.selectionConvergence_connectionPointIn()
- else:
- connection = plcopen.connectionPointIn()
+ connection = PLCOpenParser.CreateElement("connectionPointIn", divergence_type)
+ divergence.appendconnectionPointIn(connection)
connection.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(connection, input_connector)
- divergence.appendconnectionPointIn(connection)
output_connectors = value["outputs"]
- if isinstance(divergence, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)):
+ if divergence_type in ["selectionConvergence", "simultaneousConvergence"]:
position = output_connectors[0].GetRelPosition()
divergence.addconnectionPointOut()
divergence.connectionPointOut.setrelPositionXY(position.x, position.y)
@@ -2959,19 +2885,16 @@
divergence.setconnectionPointOut([])
for output_connector in output_connectors:
position = output_connector.GetRelPosition()
- if isinstance(divergence, plcopen.sfcObjects_selectionDivergence):
- connection = plcopen.selectionDivergence_connectionPointOut()
- else:
- connection = plcopen.simultaneousDivergence_connectionPointOut()
+ connection = PLCOpenParser.CreateElement("connectionPointOut", divergence_type)
+ divergence.appendconnectionPointOut(connection)
connection.setrelPositionXY(position.x, position.y)
- divergence.appendconnectionPointOut(connection)
-
+
def AddEditedElementJump(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- jump = plcopen.sfcObjects_jumpStep()
+ jump = PLCOpenParser.CreateElement("jumpStep", "sfcObjects")
jump.setlocalId(id)
- element.addinstance("jumpStep", jump)
+ element.addinstance(jump)
def SetEditedElementJumpInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2999,9 +2922,9 @@
def AddEditedElementActionBlock(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- actionBlock = plcopen.commonObjects_actionBlock()
+ actionBlock = PLCOpenParser.CreateElement("actionBlock", "commonObjects")
actionBlock.setlocalId(id)
- element.addinstance("actionBlock", actionBlock)
+ element.addinstance(actionBlock)
def SetEditedElementActionBlockInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -3030,10 +2953,9 @@
element = self.GetEditedElement(tagname)
if element is not None:
instance = element.getinstance(id)
- if isinstance(instance, plcopen.fbdObjects_block):
+ if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName())
element.removeinstance(id)
- self.Project.RefreshElementUsingTree()
def GetEditedResourceVariables(self, tagname, debug = False):
varlist = []
@@ -3053,7 +2975,8 @@
resource.setpouInstance([])
task_list = {}
for task in tasks:
- new_task = plcopen.resource_task()
+ new_task = PLCOpenParser.CreateElement("task", "resource")
+ resource.appendtask(new_task)
new_task.setname(task["Name"])
if task["Triggering"] == "Interrupt":
new_task.setsingle(task["Single"])
@@ -3073,12 +2996,16 @@
new_task.setpriority(int(task["Priority"]))
if task["Name"] != "":
task_list[task["Name"]] = new_task
- resource.appendtask(new_task)
for instance in instances:
- new_instance = plcopen.pouInstance()
+ task = task_list.get(instance["Task"])
+ if task is not None:
+ new_instance = PLCOpenParser.CreateElement("pouInstance", "task")
+ task.appendpouInstance(new_instance)
+ else:
+ new_instance = PLCOpenParser.CreateElement("pouInstance", "resource")
+ resource.appendpouInstance(new_instance)
new_instance.setname(instance["Name"])
new_instance.settypeName(instance["Type"])
- task_list.get(instance["Task"], resource).appendpouInstance(new_instance)
def GetEditedResourceInfos(self, tagname, debug = False):
resource = self.GetEditedElement(tagname, debug)
@@ -3136,31 +3063,20 @@
return tasks_data, instances_data
def OpenXMLFile(self, filepath):
- xmlfile = open(filepath, 'r')
- tree = minidom.parse(xmlfile)
- xmlfile.close()
-
- self.Project = plcopen.project()
- for child in tree.childNodes:
- if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "project":
- try:
- result = self.Project.loadXMLTree(child)
- except ValueError, e:
- return _("Project file syntax error:\n\n") + str(e)
- self.SetFilePath(filepath)
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshDataTypeHierarchy()
- self.Project.RefreshCustomBlockTypes()
- self.CreateProjectBuffer(True)
- self.ProgramChunks = []
- self.ProgramOffset = 0
- self.NextCompiledProject = self.Copy(self.Project)
- self.CurrentCompiledProject = None
- self.Buffering = False
- self.CurrentElementEditing = None
- return None
- return _("No PLC project found")
-
+ #try:
+ self.Project = LoadProject(filepath)
+ #except Exception, e:
+ # return _("Project file syntax error:\n\n") + str(e)
+ self.SetFilePath(filepath)
+ self.CreateProjectBuffer(True)
+ self.ProgramChunks = []
+ self.ProgramOffset = 0
+ self.NextCompiledProject = self.Copy(self.Project)
+ self.CurrentCompiledProject = None
+ self.Buffering = False
+ self.CurrentElementEditing = None
+ return None
+
def SaveXMLFile(self, filepath = None):
if not filepath and self.FilePath == "":
return False
@@ -3168,19 +3084,11 @@
contentheader = {"modificationDateTime": datetime.datetime(*localtime()[:6])}
self.Project.setcontentHeader(contentheader)
- text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- extras = {"xmlns" : "http://www.plcopen.org/xml/tc6.xsd",
- "xmlns:xhtml" : "http://www.w3.org/1999/xhtml",
- "xmlns:xsi" : "http://www.w3.org/2001/XMLSchema-instance",
- "xsi:schemaLocation" : "http://www.plcopen.org/xml/tc6.xsd"}
- text += self.Project.generateXMLText("project", 0, extras)
+ if filepath:
+ SaveProject(self.Project, filepath)
+ else:
+ SaveProject(self.Project, self.FilePath)
- if filepath:
- xmlfile = open(filepath,"w")
- else:
- xmlfile = open(self.FilePath,"w")
- xmlfile.write(text.encode("utf-8"))
- xmlfile.close()
self.MarkProjectAsSaved()
if filepath:
self.SetFilePath(filepath)
@@ -3207,11 +3115,11 @@
Return a copy of the project
"""
def Copy(self, model):
- return cPickle.loads(cPickle.dumps(model))
+ return deepcopy(model)
def CreateProjectBuffer(self, saved):
if self.ProjectBufferEnabled:
- self.ProjectBuffer = UndoBuffer(cPickle.dumps(self.Project), saved)
+ self.ProjectBuffer = UndoBuffer(PLCOpenParser.Dumps(self.Project), saved)
else:
self.ProjectBuffer = None
self.ProjectSaved = saved
@@ -3230,7 +3138,7 @@
def BufferProject(self):
if self.ProjectBuffer is not None:
- self.ProjectBuffer.Buffering(cPickle.dumps(self.Project))
+ self.ProjectBuffer.Buffering(PLCOpenParser.Dumps(self.Project))
else:
self.ProjectSaved = False
@@ -3242,7 +3150,7 @@
def EndBuffering(self):
if self.ProjectBuffer is not None and self.Buffering:
- self.ProjectBuffer.Buffering(cPickle.dumps(self.Project))
+ self.ProjectBuffer.Buffering(PLCOpenParser.Dumps(self.Project))
self.Buffering = False
def MarkProjectAsSaved(self):
@@ -3262,11 +3170,11 @@
def LoadPrevious(self):
self.EndBuffering()
if self.ProjectBuffer is not None:
- self.Project = cPickle.loads(self.ProjectBuffer.Previous())
+ self.Project = PLCOpenParser.Loads(self.ProjectBuffer.Previous())
def LoadNext(self):
if self.ProjectBuffer is not None:
- self.Project = cPickle.loads(self.ProjectBuffer.Next())
+ self.Project = PLCOpenParser.Loads(self.ProjectBuffer.Next())
def GetBufferState(self):
if self.ProjectBuffer is not None:
--- a/PLCGenerator.py Thu Sep 26 20:47:36 2013 +0900
+++ b/PLCGenerator.py Fri Sep 27 09:32:39 2013 +0900
@@ -22,7 +22,7 @@
#License along with this library; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-from plcopen import plcopen
+from plcopen import PLCOpenParser
from plcopen.structures import *
from types import *
import re
@@ -75,6 +75,13 @@
else:
return cmp(ay, by)
+# Helper for emulate join on element list
+def JoinList(separator, mylist):
+ if len(mylist) > 0 :
+ return reduce(lambda x, y: x + separator + y, mylist)
+ else :
+ return mylist
+
#-------------------------------------------------------------------------------
# Specific exception for PLC generating errors
#-------------------------------------------------------------------------------
@@ -126,26 +133,25 @@
(datatype.getname(), (tagname, "name")),
(" : ", ())]
basetype_content = datatype.baseType.getcontent()
- # Data type derived directly from a string type
- if basetype_content["name"] in ["string", "wstring"]:
- datatype_def += [(basetype_content["name"].upper(), (tagname, "base"))]
+ basetype_content_type = basetype_content.getLocalTag()
# Data type derived directly from a user defined type
- elif basetype_content["name"] == "derived":
- basetype_name = basetype_content["value"].getname()
+ if basetype_content_type == "derived":
+ basetype_name = basetype_content.getname()
self.GenerateDataType(basetype_name)
datatype_def += [(basetype_name, (tagname, "base"))]
# Data type is a subrange
- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
- base_type = basetype_content["value"].baseType.getcontent()
+ elif basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
+ base_type = basetype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
# Subrange derived directly from a user defined type
- if base_type["name"] == "derived":
- basetype_name = base_type["value"].getname()
+ if base_type_type == "derived":
+ basetype_name = base_type_type.getname()
self.GenerateDataType(basetype_name)
# Subrange derived directly from an elementary type
else:
- basetype_name = base_type["name"]
- min_value = basetype_content["value"].range.getlower()
- max_value = basetype_content["value"].range.getupper()
+ basetype_name = base_type_type
+ min_value = basetype_content.range.getlower()
+ max_value = basetype_content.range.getupper()
datatype_def += [(basetype_name, (tagname, "base")),
(" (", ()),
("%s"%min_value, (tagname, "lower")),
@@ -153,63 +159,59 @@
("%s"%max_value, (tagname, "upper")),
(")",())]
# Data type is an enumerated type
- elif basetype_content["name"] == "enum":
+ elif basetype_content_type == "enum":
values = [[(value.getname(), (tagname, "value", i))]
- for i, value in enumerate(basetype_content["value"].values.getvalue())]
+ for i, value in enumerate(
+ basetype_content.xpath("ppx:values/ppx:value",
+ namespaces=PLCOpenParser.NSMAP))]
datatype_def += [("(", ())]
datatype_def += JoinList([(", ", ())], values)
datatype_def += [(")", ())]
# Data type is an array
- elif basetype_content["name"] == "array":
- base_type = basetype_content["value"].baseType.getcontent()
+ elif basetype_content_type == "array":
+ base_type = basetype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
# Array derived directly from a user defined type
- if base_type["name"] == "derived":
- basetype_name = base_type["value"].getname()
+ if base_type_type == "derived":
+ basetype_name = base_type.getname()
self.GenerateDataType(basetype_name)
- # Array derived directly from a string type
- elif base_type["name"] in ["string", "wstring"]:
- basetype_name = base_type["name"].upper()
# Array derived directly from an elementary type
else:
- basetype_name = base_type["name"]
+ basetype_name = base_type_type.upper()
dimensions = [[("%s"%dimension.getlower(), (tagname, "range", i, "lower")),
("..", ()),
("%s"%dimension.getupper(), (tagname, "range", i, "upper"))]
- for i, dimension in enumerate(basetype_content["value"].getdimension())]
+ for i, dimension in enumerate(basetype_content.getdimension())]
datatype_def += [("ARRAY [", ())]
datatype_def += JoinList([(",", ())], dimensions)
datatype_def += [("] OF " , ()),
(basetype_name, (tagname, "base"))]
# Data type is a structure
- elif basetype_content["name"] == "struct":
+ elif basetype_content_type == "struct":
elements = []
- for i, element in enumerate(basetype_content["value"].getvariable()):
+ for i, element in enumerate(basetype_content.getvariable()):
element_type = element.type.getcontent()
+ element_type_type = element_type.getLocalTag()
# Structure element derived directly from a user defined type
- if element_type["name"] == "derived":
- elementtype_name = element_type["value"].getname()
+ if element_type_type == "derived":
+ elementtype_name = element_type.getname()
self.GenerateDataType(elementtype_name)
- elif element_type["name"] == "array":
- base_type = element_type["value"].baseType.getcontent()
+ elif element_type_type == "array":
+ base_type = element_type.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
# Array derived directly from a user defined type
- if base_type["name"] == "derived":
- basetype_name = base_type["value"].getname()
+ if base_type_type == "derived":
+ basetype_name = base_type.getname()
self.GenerateDataType(basetype_name)
- # Array derived directly from a string type
- elif base_type["name"] in ["string", "wstring"]:
- basetype_name = base_type["name"].upper()
# Array derived directly from an elementary type
else:
- basetype_name = base_type["name"]
+ basetype_name = base_type_type.upper()
dimensions = ["%s..%s" % (dimension.getlower(), dimension.getupper())
- for dimension in element_type["value"].getdimension()]
+ for dimension in element_type.getdimension()]
elementtype_name = "ARRAY [%s] OF %s" % (",".join(dimensions), basetype_name)
- # Structure element derived directly from a string type
- elif element_type["name"] in ["string", "wstring"]:
- elementtype_name = element_type["name"].upper()
# Structure element derived directly from an elementary type
else:
- elementtype_name = element_type["name"]
+ elementtype_name = element_type_type.upper()
element_text = [("\n ", ()),
(element.getname(), (tagname, "struct", i, "name")),
(" : ", ()),
@@ -224,7 +226,7 @@
datatype_def += [("\n END_STRUCT", ())]
# Data type derived directly from a elementary type
else:
- datatype_def += [(basetype_content["name"], (tagname, "base"))]
+ datatype_def += [(basetype_content_type.upper(), (tagname, "base"))]
# Data type has an initial value
if datatype.initialValue is not None:
datatype_def += [(" := ", ()),
@@ -269,10 +271,15 @@
varlists = [(varlist, varlist.getvariable()[:]) for varlist in configuration.getglobalVars()]
extra_variables = self.Controler.GetConfigurationExtraVariables()
- if len(extra_variables) > 0:
- if len(varlists) == 0:
- varlists = [(plcopen.interface_globalVars(), [])]
- varlists[-1][1].extend(extra_variables)
+ extra_global_vars = None
+ if len(extra_variables) > 0 and len(varlists) == 0:
+ extra_global_vars = PLCOpenParser.CreateElement("globalVars", "interface")
+ configuration.setglobalVars([extra_global_vars])
+ varlists = [(extra_global_vars, [])]
+
+ for variable in extra_variables:
+ varlists[-1][0].appendvariable(variable)
+ varlists[-1][1].append(variable)
# Generate any global variable in configuration
for varlist, varlist_variables in varlists:
@@ -289,8 +296,8 @@
# Generate any variable of this block
for var in varlist_variables:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- var_type = vartype_content["value"].getname()
+ if vartype_content.getLocalTag() == "derived":
+ var_type = vartype_content.getname()
self.GenerateDataType(var_type)
else:
var_type = var.gettypeAsText()
@@ -308,12 +315,19 @@
(var.gettypeAsText(), (tagname, variable_type, var_number, "type"))]
# Generate variable initial value if exists
initial = var.getinitialValue()
- if initial:
+ if initial is not None:
config += [(" := ", ()),
(self.ComputeValue(initial.getvalue(), var_type), (tagname, variable_type, var_number, "initial value"))]
config += [(";\n", ())]
var_number += 1
config += [(" END_VAR\n", ())]
+
+ if extra_global_vars is not None:
+ configuration.remove(extra_global_vars)
+ else:
+ for variable in extra_variables:
+ varlists[-1][1].remove(variable)
+
# Generate any resource in the configuration
for resource in configuration.getresource():
config += self.GenerateResource(resource, configuration.getname())
@@ -342,8 +356,8 @@
# Generate any variable of this block
for var in varlist.getvariable():
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- var_type = vartype_content["value"].getname()
+ if vartype_content.getLocalTag() == "derived":
+ var_type = vartype_content.getname()
self.GenerateDataType(var_type)
else:
var_type = var.gettypeAsText()
@@ -361,7 +375,7 @@
(var.gettypeAsText(), (tagname, variable_type, var_number, "type"))]
# Generate variable initial value if exists
initial = var.getinitialValue()
- if initial:
+ if initial is not None:
resrce += [(" := ", ()),
(self.ComputeValue(initial.getvalue(), var_type), (tagname, variable_type, var_number, "initial value"))]
resrce += [(";\n", ())]
@@ -378,13 +392,13 @@
args = []
single = task.getsingle()
# Single argument if exists
- if single:
+ if single is not None:
resrce += [("SINGLE := ", ()),
(single, (tagname, "task", task_number, "single")),
(",", ())]
# Interval argument if exists
interval = task.getinterval()
- if interval:
+ if interval is not None:
resrce += [("INTERVAL := ", ()),
(interval, (tagname, "task", task_number, "interval")),
(",", ())]
@@ -458,6 +472,24 @@
# Generator of POU programs
#-------------------------------------------------------------------------------
+[ConnectorClass, ContinuationClass, ActionBlockClass] = [
+ PLCOpenParser.GetElementClass(instance_name, "commonObjects")
+ for instance_name in ["connector", "continuation", "actionBlock"]]
+[InVariableClass, InOutVariableClass, OutVariableClass, BlockClass] = [
+ PLCOpenParser.GetElementClass(instance_name, "fbdObjects")
+ for instance_name in ["inVariable", "inOutVariable", "outVariable", "block"]]
+[ContactClass, CoilClass, LeftPowerRailClass, RightPowerRailClass] = [
+ PLCOpenParser.GetElementClass(instance_name, "ldObjects")
+ for instance_name in ["contact", "coil", "leftPowerRail", "rightPowerRail"]]
+[StepClass, TransitionClass, JumpStepClass,
+ SelectionConvergenceClass, SelectionDivergenceClass,
+ SimultaneousConvergenceClass, SimultaneousDivergenceClass] = [
+ PLCOpenParser.GetElementClass(instance_name, "sfcObjects")
+ for instance_name in ["step", "transition", "jumpStep",
+ "selectionConvergence", "selectionDivergence",
+ "simultaneousConvergence", "simultaneousDivergence"]]
+TransitionObjClass = PLCOpenParser.GetElementClass("transition", "transitions")
+ActionObjClass = PLCOpenParser.GetElementClass("action", "actions")
class PouProgramGenerator:
@@ -541,16 +573,17 @@
# Return connectors linked by a connection to the given connector
def GetConnectedConnector(self, connector, body):
links = connector.getconnections()
- if links and len(links) == 1:
+ if links is not None and len(links) == 1:
return self.GetLinkedConnector(links[0], body)
return None
def GetLinkedConnector(self, link, body):
parameter = link.getformalParameter()
instance = body.getcontentInstance(link.getrefLocalId())
- if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable, plcopen.commonObjects_continuation, plcopen.ldObjects_contact, plcopen.ldObjects_coil)):
+ if isinstance(instance, (InVariableClass, InOutVariableClass,
+ ContinuationClass, ContactClass, CoilClass)):
return instance.connectionPointOut
- elif isinstance(instance, plcopen.fbdObjects_block):
+ elif isinstance(instance, BlockClass):
outputvariables = instance.outputVariables.getvariable()
if len(outputvariables) == 1:
return outputvariables[0].connectionPointOut
@@ -565,7 +598,7 @@
blockposition = instance.getposition()
if point.x == blockposition.x + relposition[0] and point.y == blockposition.y + relposition[1]:
return variable.connectionPointOut
- elif isinstance(instance, plcopen.ldObjects_leftPowerRail):
+ elif isinstance(instance, LeftPowerRailClass):
outputconnections = instance.getconnectionPointOut()
if len(outputconnections) == 1:
return outputconnections[0]
@@ -591,49 +624,42 @@
if isinstance(body, ListType):
body = body[0]
body_content = body.getcontent()
+ body_type = body_content.getLocalTag()
if self.Type == "FUNCTION":
returntype_content = interface.getreturnType().getcontent()
- if returntype_content["name"] == "derived":
- self.ReturnType = returntype_content["value"].getname()
- elif returntype_content["name"] in ["string", "wstring"]:
- self.ReturnType = returntype_content["name"].upper()
- else:
- self.ReturnType = returntype_content["name"]
+ returntype_content_type = returntype_content.getLocalTag()
+ if returntype_content_type == "derived":
+ self.ReturnType = returntype_content.getname()
+ else:
+ self.ReturnType = returntype_content_type.upper()
for varlist in interface.getcontent():
variables = []
located = []
- for var in varlist["value"].getvariable():
+ varlist_type = varlist.getLocalTag()
+ for var in varlist.getvariable():
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- var_type = vartype_content["value"].getname()
+ if vartype_content.getLocalTag() == "derived":
+ var_type = vartype_content.getname()
blocktype = self.GetBlockType(var_type)
if blocktype is not None:
self.ParentGenerator.GeneratePouProgram(var_type)
- if body_content["name"] in ["FBD", "LD", "SFC"]:
- block = pou.getinstanceByName(var.getname())
- else:
- block = None
- for variable in blocktype["initialise"](var_type, var.getname(), block):
- if variable[2] is not None:
- located.append(variable)
- else:
- variables.append(variable)
+ variables.append((var_type, var.getname(), None, None))
else:
self.ParentGenerator.GenerateDataType(var_type)
initial = var.getinitialValue()
- if initial:
+ if initial is not None:
initial_value = initial.getvalue()
else:
initial_value = None
address = var.getaddress()
if address is not None:
- located.append((vartype_content["value"].getname(), var.getname(), address, initial_value))
+ located.append((vartype_content.getname(), var.getname(), address, initial_value))
else:
- variables.append((vartype_content["value"].getname(), var.getname(), None, initial_value))
+ variables.append((vartype_content.getname(), var.getname(), None, initial_value))
else:
var_type = var.gettypeAsText()
initial = var.getinitialValue()
- if initial:
+ if initial is not None:
initial_value = initial.getvalue()
else:
initial_value = None
@@ -642,18 +668,18 @@
located.append((var_type, var.getname(), address, initial_value))
else:
variables.append((var_type, var.getname(), None, initial_value))
- if varlist["value"].getconstant():
+ if varlist.getconstant():
option = "CONSTANT"
- elif varlist["value"].getretain():
+ elif varlist.getretain():
option = "RETAIN"
- elif varlist["value"].getnonretain():
+ elif varlist.getnonretain():
option = "NON_RETAIN"
else:
option = None
if len(variables) > 0:
- self.Interface.append((varTypeNames[varlist["name"]], option, False, variables))
+ self.Interface.append((varTypeNames[varlist_type], option, False, variables))
if len(located) > 0:
- self.Interface.append((varTypeNames[varlist["name"]], option, True, located))
+ self.Interface.append((varTypeNames[varlist_type], option, True, located))
LITERAL_TYPES = {
"T": "TIME",
@@ -669,24 +695,25 @@
if isinstance(body, ListType):
body = body[0]
body_content = body.getcontent()
- body_type = body_content["name"]
+ body_type = body_content.getLocalTag()
if body_type in ["FBD", "LD", "SFC"]:
undefined_blocks = []
for instance in body.getcontentInstances():
- if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
+ if isinstance(instance, (InVariableClass, OutVariableClass,
+ InOutVariableClass)):
expression = instance.getexpression()
var_type = self.GetVariableType(expression)
- if isinstance(pou, plcopen.transitions_transition) and expression == pou.getname():
+ if (isinstance(pou, TransitionObjClass)
+ and expression == pou.getname()):
var_type = "BOOL"
- elif (not isinstance(pou, (plcopen.transitions_transition, plcopen.actions_action)) and
+ elif (not isinstance(pou, (TransitionObjClass, ActionObjClass)) and
pou.getpouType() == "function" and expression == pou.getname()):
returntype_content = pou.interface.getreturnType().getcontent()
- if returntype_content["name"] == "derived":
- var_type = returntype_content["value"].getname()
- elif returntype_content["name"] in ["string", "wstring"]:
- var_type = returntype_content["name"].upper()
+ returntype_content_type = returntype_content.getLocalTag()
+ if returntype_content_type == "derived":
+ var_type = returntype_content.getname()
else:
- var_type = returntype_content["name"]
+ var_type = returntype_content_type.upper()
elif var_type is None:
parts = expression.split("#")
if len(parts) > 1:
@@ -698,54 +725,58 @@
elif expression.startswith('"'):
var_type = "WSTRING"
if var_type is not None:
- if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable)):
+ if isinstance(instance, (InVariableClass, InOutVariableClass)):
for connection in self.ExtractRelatedConnections(instance.connectionPointOut):
self.ConnectionTypes[connection] = var_type
- if isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
+ if isinstance(instance, (OutVariableClass, InOutVariableClass)):
self.ConnectionTypes[instance.connectionPointIn] = var_type
connected = self.GetConnectedConnector(instance.connectionPointIn, body)
- if connected and not self.ConnectionTypes.has_key(connected):
- for connection in self.ExtractRelatedConnections(connected):
- self.ConnectionTypes[connection] = var_type
- elif isinstance(instance, (plcopen.ldObjects_contact, plcopen.ldObjects_coil)):
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
+ for related in self.ExtractRelatedConnections(connected):
+ self.ConnectionTypes[related] = var_type
+ elif isinstance(instance, (ContactClass, CoilClass)):
for connection in self.ExtractRelatedConnections(instance.connectionPointOut):
self.ConnectionTypes[connection] = "BOOL"
self.ConnectionTypes[instance.connectionPointIn] = "BOOL"
- connected = self.GetConnectedConnector(instance.connectionPointIn, body)
- if connected and not self.ConnectionTypes.has_key(connected):
- for connection in self.ExtractRelatedConnections(connected):
- self.ConnectionTypes[connection] = "BOOL"
- elif isinstance(instance, plcopen.ldObjects_leftPowerRail):
+ for link in instance.connectionPointIn.getconnections():
+ connected = self.GetLinkedConnector(link, body)
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
+ for related in self.ExtractRelatedConnections(connected):
+ self.ConnectionTypes[related] = "BOOL"
+ elif isinstance(instance, LeftPowerRailClass):
for connection in instance.getconnectionPointOut():
for related in self.ExtractRelatedConnections(connection):
self.ConnectionTypes[related] = "BOOL"
- elif isinstance(instance, plcopen.ldObjects_rightPowerRail):
+ elif isinstance(instance, RightPowerRailClass):
for connection in instance.getconnectionPointIn():
self.ConnectionTypes[connection] = "BOOL"
- connected = self.GetConnectedConnector(connection, body)
- if connected and not self.ConnectionTypes.has_key(connected):
- for connection in self.ExtractRelatedConnections(connected):
- self.ConnectionTypes[connection] = "BOOL"
- elif isinstance(instance, plcopen.sfcObjects_transition):
- content = instance.condition.getcontent()
- if content["name"] == "connection" and len(content["value"]) == 1:
- connected = self.GetLinkedConnector(content["value"][0], body)
- if connected and not self.ConnectionTypes.has_key(connected):
- for connection in self.ExtractRelatedConnections(connected):
- self.ConnectionTypes[connection] = "BOOL"
- elif isinstance(instance, plcopen.commonObjects_continuation):
+ for link in connection.getconnections():
+ connected = self.GetLinkedConnector(link, body)
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
+ for related in self.ExtractRelatedConnections(connected):
+ self.ConnectionTypes[related] = "BOOL"
+ elif isinstance(instance, TransitionClass):
+ content = instance.getconditionContent()
+ if content["type"] == "connection":
+ self.ConnectionTypes[content["value"]] = "BOOL"
+ for link in content["value"].getconnections():
+ connected = self.GetLinkedConnector(link, body)
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
+ for related in self.ExtractRelatedConnections(connected):
+ self.ConnectionTypes[related] = "BOOL"
+ elif isinstance(instance, ContinuationClass):
name = instance.getname()
connector = None
var_type = "ANY"
for element in body.getcontentInstances():
- if isinstance(element, plcopen.commonObjects_connector) and element.getname() == name:
+ if isinstance(element, ConnectorClass) and element.getname() == name:
if connector is not None:
raise PLCGenException, _("More than one connector found corresponding to \"%s\" continuation in \"%s\" POU")%(name, self.Name)
connector = element
if connector is not None:
undefined = [instance.connectionPointOut, connector.connectionPointIn]
connected = self.GetConnectedConnector(connector.connectionPointIn, body)
- if connected:
+ if connected is not None:
undefined.append(connected)
related = []
for connection in undefined:
@@ -760,7 +791,7 @@
self.ConnectionTypes[connection] = var_type
else:
raise PLCGenException, _("No connector found corresponding to \"%s\" continuation in \"%s\" POU")%(name, self.Name)
- elif isinstance(instance, plcopen.fbdObjects_block):
+ elif isinstance(instance, BlockClass):
block_infos = self.GetBlockType(instance.gettypeName(), "undefined")
if block_infos is not None:
self.ComputeBlockInputTypes(instance, block_infos, body)
@@ -822,11 +853,11 @@
if not undefined.has_key(itype):
undefined[itype] = []
undefined[itype].append(variable.connectionPointIn)
- if connected:
+ if connected is not None:
undefined[itype].append(connected)
else:
self.ConnectionTypes[variable.connectionPointIn] = itype
- if connected and not self.ConnectionTypes.has_key(connected):
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
for connection in self.ExtractRelatedConnections(connected):
self.ConnectionTypes[connection] = itype
for var_type, connections in undefined.items():
@@ -848,22 +879,22 @@
if isinstance(body, ListType):
body = body[0]
body_content = body.getcontent()
- body_type = body_content["name"]
+ body_type = body_content.getLocalTag()
if body_type in ["IL","ST"]:
- text = body_content["value"].gettext()
+ text = body_content.getanyText()
self.ParentGenerator.GeneratePouProgramInText(text.upper())
self.Program = [(ReIndentText(text, len(self.CurrentIndent)),
(self.TagName, "body", len(self.CurrentIndent)))]
elif body_type == "SFC":
self.IndentRight()
for instance in body.getcontentInstances():
- if isinstance(instance, plcopen.sfcObjects_step):
+ if isinstance(instance, StepClass):
self.GenerateSFCStep(instance, pou)
- elif isinstance(instance, plcopen.commonObjects_actionBlock):
+ elif isinstance(instance, ActionBlockClass):
self.GenerateSFCStepActions(instance, pou)
- elif isinstance(instance, plcopen.sfcObjects_transition):
+ elif isinstance(instance, TransitionClass):
self.GenerateSFCTransition(instance, pou)
- elif isinstance(instance, plcopen.sfcObjects_jumpStep):
+ elif isinstance(instance, JumpStepClass):
self.GenerateSFCJump(instance, pou)
if len(self.InitialSteps) > 0 and len(self.SFCComputedBlocks) > 0:
action_name = "COMPUTE_FUNCTION_BLOCKS"
@@ -878,17 +909,17 @@
otherInstances = {"outVariables&coils" : [], "blocks" : [], "connectors" : []}
orderedInstances = []
for instance in body.getcontentInstances():
- if isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable, plcopen.fbdObjects_block)):
+ if isinstance(instance, (OutVariableClass, InOutVariableClass, BlockClass)):
executionOrderId = instance.getexecutionOrderId()
if executionOrderId > 0:
orderedInstances.append((executionOrderId, instance))
- elif isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
+ elif isinstance(instance, (OutVariableClass, InOutVariableClass)):
otherInstances["outVariables&coils"].append(instance)
- elif isinstance(instance, plcopen.fbdObjects_block):
+ elif isinstance(instance, BlockClass):
otherInstances["blocks"].append(instance)
- elif isinstance(instance, plcopen.commonObjects_connector):
+ elif isinstance(instance, ConnectorClass):
otherInstances["connectors"].append(instance)
- elif isinstance(instance, plcopen.ldObjects_coil):
+ elif isinstance(instance, CoilClass):
otherInstances["outVariables&coils"].append(instance)
orderedInstances.sort()
otherInstances["outVariables&coils"].sort(SortInstances)
@@ -896,7 +927,7 @@
instances = [instance for (executionOrderId, instance) in orderedInstances]
instances.extend(otherInstances["outVariables&coils"] + otherInstances["blocks"] + otherInstances["connectors"])
for instance in instances:
- if isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
+ if isinstance(instance, (OutVariableClass, InOutVariableClass)):
connections = instance.connectionPointIn.getconnections()
if connections is not None:
expression = self.ComputeExpression(body, connections)
@@ -906,7 +937,7 @@
(" := ", ())]
self.Program += expression
self.Program += [(";\n", ())]
- elif isinstance(instance, plcopen.fbdObjects_block):
+ elif isinstance(instance, BlockClass):
block_type = instance.gettypeName()
self.ParentGenerator.GeneratePouProgram(block_type)
block_infos = self.GetBlockType(block_type, tuple([self.ConnectionTypes.get(variable.connectionPointIn, "ANY") for variable in instance.inputVariables.getvariable() if variable.getformalParameter() != "EN"]))
@@ -915,17 +946,17 @@
if block_infos is None:
raise PLCGenException, _("Undefined block type \"%s\" in \"%s\" POU")%(block_type, self.Name)
try:
- block_infos["generate"](self, instance, block_infos, body, None)
+ self.GenerateBlock(instance, block_infos, body, None)
except ValueError, e:
raise PLCGenException, e.message
- elif isinstance(instance, plcopen.commonObjects_connector):
+ elif isinstance(instance, ConnectorClass):
connector = instance.getname()
if self.ComputedConnectors.get(connector, None):
continue
expression = self.ComputeExpression(body, instance.connectionPointIn.getconnections())
if expression is not None:
self.ComputedConnectors[connector] = expression
- elif isinstance(instance, plcopen.ldObjects_coil):
+ elif isinstance(instance, CoilClass):
connections = instance.connectionPointIn.getconnections()
if connections is not None:
coil_info = (self.TagName, "coil", instance.getlocalId())
@@ -963,16 +994,201 @@
factorized_paths.sort()
return factorized_paths
+ def GenerateBlock(self, block, block_infos, body, link, order=False, to_inout=False):
+ body_type = body.getcontent().getLocalTag()
+ name = block.getinstanceName()
+ type = block.gettypeName()
+ executionOrderId = block.getexecutionOrderId()
+ input_variables = block.inputVariables.getvariable()
+ output_variables = block.outputVariables.getvariable()
+ inout_variables = {}
+ for input_variable in input_variables:
+ for output_variable in output_variables:
+ if input_variable.getformalParameter() == output_variable.getformalParameter():
+ inout_variables[input_variable.getformalParameter()] = ""
+ input_names = [input[0] for input in block_infos["inputs"]]
+ output_names = [output[0] for output in block_infos["outputs"]]
+ if block_infos["type"] == "function":
+ if not self.ComputedBlocks.get(block, False) and not order:
+ self.ComputedBlocks[block] = True
+ connected_vars = []
+ if not block_infos["extensible"]:
+ input_connected = dict([("EN", None)] +
+ [(input_name, None) for input_name in input_names])
+ for variable in input_variables:
+ parameter = variable.getformalParameter()
+ if input_connected.has_key(parameter):
+ input_connected[parameter] = variable
+ if input_connected["EN"] is None:
+ input_connected.pop("EN")
+ input_parameters = input_names
+ else:
+ input_parameters = ["EN"] + input_names
+ else:
+ input_connected = dict([(variable.getformalParameter(), variable)
+ for variable in input_variables])
+ input_parameters = [variable.getformalParameter()
+ for variable in input_variables]
+ one_input_connected = False
+ all_input_connected = True
+ for i, parameter in enumerate(input_parameters):
+ variable = input_connected.get(parameter)
+ if variable is not None:
+ input_info = (self.TagName, "block", block.getlocalId(), "input", i)
+ connections = variable.connectionPointIn.getconnections()
+ if connections is not None:
+ if parameter != "EN":
+ one_input_connected = True
+ if inout_variables.has_key(parameter):
+ expression = self.ComputeExpression(body, connections, executionOrderId > 0, True)
+ if expression is not None:
+ inout_variables[parameter] = value
+ else:
+ expression = self.ComputeExpression(body, connections, executionOrderId > 0)
+ if expression is not None:
+ connected_vars.append(([(parameter, input_info), (" := ", ())],
+ self.ExtractModifier(variable, expression, input_info)))
+ else:
+ all_input_connected = False
+ else:
+ all_input_connected = False
+ if len(output_variables) > 1 or not all_input_connected:
+ vars = [name + value for name, value in connected_vars]
+ else:
+ vars = [value for name, value in connected_vars]
+ if one_input_connected:
+ for i, variable in enumerate(output_variables):
+ parameter = variable.getformalParameter()
+ if not inout_variables.has_key(parameter) and parameter in output_names + ["", "ENO"]:
+ if variable.getformalParameter() == "":
+ variable_name = "%s%d"%(type, block.getlocalId())
+ else:
+ variable_name = "%s%d_%s"%(type, block.getlocalId(), parameter)
+ if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:
+ self.Interface.append(("VAR", None, False, []))
+ if variable.connectionPointOut in self.ConnectionTypes:
+ self.Interface[-1][3].append((self.ConnectionTypes[variable.connectionPointOut], variable_name, None, None))
+ else:
+ self.Interface[-1][3].append(("ANY", variable_name, None, None))
+ if len(output_variables) > 1 and parameter not in ["", "OUT"]:
+ vars.append([(parameter, (self.TagName, "block", block.getlocalId(), "output", i)),
+ (" => %s"%variable_name, ())])
+ else:
+ output_info = (self.TagName, "block", block.getlocalId(), "output", i)
+ output_name = variable_name
+ self.Program += [(self.CurrentIndent, ()),
+ (output_name, output_info),
+ (" := ", ()),
+ (type, (self.TagName, "block", block.getlocalId(), "type")),
+ ("(", ())]
+ self.Program += JoinList([(", ", ())], vars)
+ self.Program += [(");\n", ())]
+ else:
+ self.Warnings.append(_("\"%s\" function cancelled in \"%s\" POU: No input connected")%(type, self.TagName.split("::")[-1]))
+ elif block_infos["type"] == "functionBlock":
+ if not self.ComputedBlocks.get(block, False) and not order:
+ self.ComputedBlocks[block] = True
+ vars = []
+ offset_idx = 0
+ for variable in input_variables:
+ parameter = variable.getformalParameter()
+ if parameter in input_names or parameter == "EN":
+ if parameter == "EN":
+ input_idx = 0
+ offset_idx = 1
+ else:
+ input_idx = offset_idx + input_names.index(parameter)
+ input_info = (self.TagName, "block", block.getlocalId(), "input", input_idx)
+ connections = variable.connectionPointIn.getconnections()
+ if connections is not None:
+ expression = self.ComputeExpression(body, connections, executionOrderId > 0, inout_variables.has_key(parameter))
+ if expression is not None:
+ vars.append([(parameter, input_info),
+ (" := ", ())] + self.ExtractModifier(variable, expression, input_info))
+ self.Program += [(self.CurrentIndent, ()),
+ (name, (self.TagName, "block", block.getlocalId(), "name")),
+ ("(", ())]
+ self.Program += JoinList([(", ", ())], vars)
+ self.Program += [(");\n", ())]
+
+ if link is not None:
+ connectionPoint = link.getposition()[-1]
+ output_parameter = link.getformalParameter()
+ else:
+ connectionPoint = None
+ output_parameter = None
+
+ output_variable = None
+ output_idx = 0
+ if output_parameter is not None:
+ if output_parameter in output_names or output_parameter == "ENO":
+ for variable in output_variables:
+ if variable.getformalParameter() == output_parameter:
+ output_variable = variable
+ if output_parameter != "ENO":
+ output_idx = output_names.index(output_parameter)
+ else:
+ for i, variable in enumerate(output_variables):
+ blockPointx, blockPointy = variable.connectionPointOut.getrelPositionXY()
+ if (connectionPoint is None or
+ block.getx() + blockPointx == connectionPoint.getx() and
+ block.gety() + blockPointy == connectionPoint.gety()):
+ output_variable = variable
+ output_parameter = variable.getformalParameter()
+ output_idx = i
+
+ if output_variable is not None:
+ if block_infos["type"] == "function":
+ output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx)
+ if inout_variables.has_key(output_parameter):
+ output_value = inout_variables[output_parameter]
+ else:
+ if output_parameter == "":
+ output_name = "%s%d"%(type, block.getlocalId())
+ else:
+ output_name = "%s%d_%s"%(type, block.getlocalId(), output_parameter)
+ output_value = [(output_name, output_info)]
+ return self.ExtractModifier(output_variable, output_value, output_info)
+
+ if block_infos["type"] == "functionBlock":
+ output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx)
+ output_name = self.ExtractModifier(output_variable, [("%s.%s"%(name, output_parameter), output_info)], output_info)
+ if to_inout:
+ variable_name = "%s_%s"%(name, output_parameter)
+ if not self.IsAlreadyDefined(variable_name):
+ if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:
+ self.Interface.append(("VAR", None, False, []))
+ if variable.connectionPointOut in self.ConnectionTypes:
+ self.Interface[-1][3].append(
+ (self.ConnectionTypes[output_variable.connectionPointOut], variable_name, None, None))
+ else:
+ self.Interface[-1][3].append(("ANY", variable_name, None, None))
+ self.Program += [(self.CurrentIndent, ()),
+ ("%s := "%variable_name, ())]
+ self.Program += output_name
+ self.Program += [(";\n", ())]
+ return [(variable_name, ())]
+ return output_name
+ if link is not None:
+ if output_parameter is None:
+ output_parameter = ""
+ if name:
+ blockname = "%s(%s)" % (name, type)
+ else:
+ blockname = type
+ raise ValueError, _("No output %s variable found in block %s in POU %s. Connection must be broken") % \
+ (output_parameter, blockname, self.Name)
+
def GeneratePaths(self, connections, body, order = False, to_inout = False):
paths = []
for connection in connections:
localId = connection.getrefLocalId()
next = body.getcontentInstance(localId)
- if isinstance(next, plcopen.ldObjects_leftPowerRail):
+ if isinstance(next, LeftPowerRailClass):
paths.append(None)
- elif isinstance(next, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable)):
+ elif isinstance(next, (InVariableClass, InOutVariableClass)):
paths.append(str([(next.getexpression(), (self.TagName, "io_variable", localId, "expression"))]))
- elif isinstance(next, plcopen.fbdObjects_block):
+ elif isinstance(next, BlockClass):
block_type = next.gettypeName()
self.ParentGenerator.GeneratePouProgram(block_type)
block_infos = self.GetBlockType(block_type, tuple([self.ConnectionTypes.get(variable.connectionPointIn, "ANY") for variable in next.inputVariables.getvariable() if variable.getformalParameter() != "EN"]))
@@ -981,10 +1197,10 @@
if block_infos is None:
raise PLCGenException, _("Undefined block type \"%s\" in \"%s\" POU")%(block_type, self.Name)
try:
- paths.append(str(block_infos["generate"](self, next, block_infos, body, connection, order, to_inout)))
+ paths.append(str(self.GenerateBlock(next, block_infos, body, connection, order, to_inout)))
except ValueError, e:
raise PLCGenException, e.message
- elif isinstance(next, plcopen.commonObjects_continuation):
+ elif isinstance(next, ContinuationClass):
name = next.getname()
computed_value = self.ComputedConnectors.get(name, None)
if computed_value != None:
@@ -992,7 +1208,7 @@
else:
connector = None
for instance in body.getcontentInstances():
- if isinstance(instance, plcopen.commonObjects_connector) and instance.getname() == name:
+ if isinstance(instance, ConnectorClass) and instance.getname() == name:
if connector is not None:
raise PLCGenException, _("More than one connector found corresponding to \"%s\" continuation in \"%s\" POU")%(name, self.Name)
connector = instance
@@ -1005,7 +1221,7 @@
paths.append(str(expression))
else:
raise PLCGenException, _("No connector found corresponding to \"%s\" continuation in \"%s\" POU")%(name, self.Name)
- elif isinstance(next, plcopen.ldObjects_contact):
+ elif isinstance(next, ContactClass):
contact_info = (self.TagName, "contact", next.getlocalId())
variable = str(self.ExtractModifier(next, [(next.getvariable(), contact_info + ("reference",))], contact_info))
result = self.GeneratePaths(next.connectionPointIn.getconnections(), body, order)
@@ -1021,7 +1237,7 @@
paths.append([variable, result[0]])
else:
paths.append(variable)
- elif isinstance(next, plcopen.ldObjects_coil):
+ elif isinstance(next, CoilClass):
paths.append(str(self.GeneratePaths(next.connectionPointIn.getconnections(), body, order)))
return paths
@@ -1092,7 +1308,7 @@
def ExtractDivergenceInput(self, divergence, pou):
connectionPointIn = divergence.getconnectionPointIn()
- if connectionPointIn:
+ if connectionPointIn is not None:
connections = connectionPointIn.getconnections()
if connections is not None and len(connections) == 1:
instanceLocalId = connections[0].getrefLocalId()
@@ -1124,7 +1340,7 @@
"transitions" : [],
"actions" : []}
self.SFCNetworks["Steps"][step_name] = step_infos
- if step.connectionPointIn:
+ if step.connectionPointIn is not None:
instances = []
connections = step.connectionPointIn.getconnections()
if connections is not None and len(connections) == 1:
@@ -1133,16 +1349,16 @@
if isinstance(body, ListType):
body = body[0]
instance = body.getcontentInstance(instanceLocalId)
- if isinstance(instance, plcopen.sfcObjects_transition):
+ if isinstance(instance, TransitionClass):
instances.append(instance)
- elif isinstance(instance, plcopen.sfcObjects_selectionConvergence):
+ elif isinstance(instance, SelectionConvergenceClass):
instances.extend(self.ExtractConvergenceInputs(instance, pou))
- elif isinstance(instance, plcopen.sfcObjects_simultaneousDivergence):
+ elif isinstance(instance, SimultaneousDivergenceClass):
transition = self.ExtractDivergenceInput(instance, pou)
- if transition:
- if isinstance(transition, plcopen.sfcObjects_transition):
+ if transition is not None:
+ if isinstance(transition, TransitionClass):
instances.append(transition)
- elif isinstance(transition, plcopen.sfcObjects_selectionConvergence):
+ elif isinstance(transition, SelectionConvergenceClass):
instances.extend(self.ExtractConvergenceInputs(transition, pou))
for instance in instances:
self.GenerateSFCTransition(instance, pou)
@@ -1152,7 +1368,7 @@
def GenerateSFCJump(self, jump, pou):
jump_target = jump.gettargetName()
- if jump.connectionPointIn:
+ if jump.connectionPointIn is not None:
instances = []
connections = jump.connectionPointIn.getconnections()
if connections is not None and len(connections) == 1:
@@ -1161,16 +1377,16 @@
if isinstance(body, ListType):
body = body[0]
instance = body.getcontentInstance(instanceLocalId)
- if isinstance(instance, plcopen.sfcObjects_transition):
+ if isinstance(instance, TransitionClass):
instances.append(instance)
- elif isinstance(instance, plcopen.sfcObjects_selectionConvergence):
+ elif isinstance(instance, SelectionConvergenceClass):
instances.extend(self.ExtractConvergenceInputs(instance, pou))
- elif isinstance(instance, plcopen.sfcObjects_simultaneousDivergence):
+ elif isinstance(instance, SimultaneousDivergenceClass):
transition = self.ExtractDivergenceInput(instance, pou)
- if transition:
- if isinstance(transition, plcopen.sfcObjects_transition):
+ if transition is not None:
+ if isinstance(transition, TransitionClass):
instances.append(transition)
- elif isinstance(transition, plcopen.sfcObjects_selectionConvergence):
+ elif isinstance(transition, SelectionConvergenceClass):
instances.extend(self.ExtractConvergenceInputs(transition, pou))
for instance in instances:
self.GenerateSFCTransition(instance, pou)
@@ -1212,7 +1428,7 @@
def GenerateSFCAction(self, action_name, pou):
if action_name not in self.SFCNetworks["Actions"].keys():
actionContent = pou.getaction(action_name)
- if actionContent:
+ if actionContent is not None:
previous_tagname = self.TagName
self.TagName = self.ParentGenerator.Controler.ComputePouActionName(self.Name, action_name)
self.ComputeProgram(actionContent)
@@ -1230,21 +1446,22 @@
if isinstance(body, ListType):
body = body[0]
instance = body.getcontentInstance(instanceLocalId)
- if isinstance(instance, plcopen.sfcObjects_step):
+ if isinstance(instance, StepClass):
steps.append(instance)
- elif isinstance(instance, plcopen.sfcObjects_selectionDivergence):
+ elif isinstance(instance, SelectionDivergenceClass):
step = self.ExtractDivergenceInput(instance, pou)
- if step:
- if isinstance(step, plcopen.sfcObjects_step):
+ if step is not None:
+ if isinstance(step, StepClass):
steps.append(step)
- elif isinstance(step, plcopen.sfcObjects_simultaneousConvergence):
+ elif isinstance(step, SimultaneousConvergenceClass):
steps.extend(self.ExtractConvergenceInputs(step, pou))
- elif isinstance(instance, plcopen.sfcObjects_simultaneousConvergence):
+ elif isinstance(instance, SimultaneousConvergenceClass):
steps.extend(self.ExtractConvergenceInputs(instance, pou))
transition_infos = {"id" : transition.getlocalId(),
"priority": transition.getpriority(),
"from": [],
- "to" : []}
+ "to" : [],
+ "content": []}
self.SFCNetworks["Transitions"][transition] = transition_infos
transitionValues = transition.getconditionContent()
if transitionValues["type"] == "inline":
@@ -1259,14 +1476,14 @@
self.TagName = self.ParentGenerator.Controler.ComputePouTransitionName(self.Name, transitionValues["value"])
if transitionType == "IL":
transition_infos["content"] = [(":\n", ()),
- (ReIndentText(transitionBody.gettext(), len(self.CurrentIndent)), (self.TagName, "body", len(self.CurrentIndent)))]
+ (ReIndentText(transitionBody.getanyText(), len(self.CurrentIndent)), (self.TagName, "body", len(self.CurrentIndent)))]
elif transitionType == "ST":
transition_infos["content"] = [("\n", ()),
- (ReIndentText(transitionBody.gettext(), len(self.CurrentIndent)), (self.TagName, "body", len(self.CurrentIndent)))]
+ (ReIndentText(transitionBody.getanyText(), len(self.CurrentIndent)), (self.TagName, "body", len(self.CurrentIndent)))]
else:
for instance in transitionBody.getcontentInstances():
- if isinstance(instance, plcopen.fbdObjects_outVariable) and instance.getexpression() == transitionValues["value"]\
- or isinstance(instance, plcopen.ldObjects_coil) and instance.getvariable() == transitionValues["value"]:
+ if isinstance(instance, OutVariableClass) and instance.getexpression() == transitionValues["value"]\
+ or isinstance(instance, CoilClass) and instance.getvariable() == transitionValues["value"]:
connections = instance.connectionPointIn.getconnections()
if connections is not None:
expression = self.ComputeExpression(transitionBody, connections)
@@ -1281,7 +1498,7 @@
body = pou.getbody()
if isinstance(body, ListType):
body = body[0]
- connections = transition.getconnections()
+ connections = transitionValues["value"].getconnections()
if connections is not None:
expression = self.ComputeExpression(body, connections)
if expression is not None:
@@ -1335,7 +1552,7 @@
action_content, action_info = self.SFCNetworks["Actions"].pop(action_name)
self.Program += [("%sACTION "%self.CurrentIndent, ()),
(action_name, action_info),
- (" :\n", ())]
+ (":\n", ())]
self.Program += action_content
self.Program += [("%sEND_ACTION\n\n"%self.CurrentIndent, ())]
@@ -1377,7 +1594,7 @@
program = [("%s "%self.Type, ()),
(self.Name, (self.TagName, "name"))]
- if self.ReturnType:
+ if self.ReturnType is not None:
program += [(" : ", ()),
(self.ReturnType, (self.TagName, "return"))]
program += [("\n", ())]
--- a/PLCOpenEditor.py Thu Sep 26 20:47:36 2013 +0900
+++ b/PLCOpenEditor.py Fri Sep 27 09:32:39 2013 +0900
@@ -276,6 +276,7 @@
self.Controler = PLCControler()
self.Controler.CreateNewProject(properties)
self.LibraryPanel.SetController(self.Controler)
+ self.ProjectTree.Enable(True)
self._Refresh(TITLE, FILEMENU, EDITMENU, PROJECTTREE, POUINSTANCEVARIABLESPANEL,
LIBRARYTREE)
@@ -331,9 +332,9 @@
header, icon = _("Done"), wx.ICON_INFORMATION
if os.path.isdir(os.path.dirname(filepath)):
program, errors, warnings = self.Controler.GenerateProgram(filepath)
- message_text += "".join([_("warning: %s\n") for warning in warnings])
+ message_text += "".join([_("warning: %s\n") % warning for warning in warnings])
if len(errors) > 0:
- message_text += "".join([_("error: %s\n") for error in errors])
+ message_text += "".join([_("error: %s\n") % error for error in errors])
message_text += _("Can't generate program to file %s!")%filepath
header, icon = _("Error"), wx.ICON_ERROR
else:
--- a/ProjectController.py Thu Sep 26 20:47:36 2013 +0900
+++ b/ProjectController.py Fri Sep 27 09:32:39 2013 +0900
@@ -221,9 +221,11 @@
def GetTarget(self):
target = self.BeremizRoot.getTargetType()
if target.getcontent() is None:
- target = self.Classes["BeremizRoot_TargetType"]()
+ temp_root = self.Parser.CreateRoot()
+ target = self.Parser.CreateElement("TargetType", "BeremizRoot")
+ temp_root.setTargetType(target)
target_name = self.GetDefaultTargetName()
- target.setcontent({"name": target_name, "value": self.Classes["TargetType_%s"%target_name]()})
+ target.setcontent(self.Parser.CreateElement(target_name, "TargetType"))
return target
def GetParamsAttributes(self, path = None):
@@ -659,7 +661,7 @@
Return a Builder (compile C code into machine code)
"""
# Get target, module and class name
- targetname = self.GetTarget().getcontent()["name"]
+ targetname = self.GetTarget().getcontent().getLocalTag()
targetclass = targets.GetBuilder(targetname)
# if target already
@@ -861,7 +863,7 @@
"init_calls":"\n",
"cleanup_calls":"\n"
}
- plc_main_code += targets.GetTargetCode(self.GetTarget().getcontent()["name"])
+ plc_main_code += targets.GetTargetCode(self.GetTarget().getcontent().getLocalTag())
plc_main_code += targets.GetCode("plc_main_tail")
return plc_main_code
--- a/c_ext/c_ext.py Thu Sep 26 20:47:36 2013 +0900
+++ b/c_ext/c_ext.py Fri Sep 27 09:32:39 2013 +0900
@@ -25,9 +25,6 @@
"publishFunction"]
EditorType = CFileEditor
- def GenerateClassesFromXSDstring(self, xsd_string):
- return GenerateClassesFromXSDstring(xsd_string)
-
def GetIconName(self):
return "Cfile"
@@ -56,7 +53,7 @@
# Adding includes
text += "/* User includes */\n"
- text += self.CodeFile.includes.gettext().strip()
+ text += self.CodeFile.includes.getanyText().strip()
text += "\n"
text += '#include "iec_types_all.h"\n\n'
@@ -76,25 +73,25 @@
# Adding user global variables and routines
text += "/* User internal user variables and routines */\n"
- text += self.CodeFile.globals.gettext().strip()
+ text += self.CodeFile.globals.getanyText().strip()
text += "\n"
# Adding Beremiz confnode functions
text += "/* Beremiz confnode functions */\n"
text += "int __init_%s(int argc,char **argv)\n{\n"%location_str
- text += self.CodeFile.initFunction.gettext().strip()
+ text += self.CodeFile.initFunction.getanyText().strip()
text += " return 0;\n}\n\n"
text += "void __cleanup_%s(void)\n{\n"%location_str
- text += self.CodeFile.cleanUpFunction.gettext().strip()
+ text += self.CodeFile.cleanUpFunction.getanyText().strip()
text += "\n}\n\n"
text += "void __retrieve_%s(void)\n{\n"%location_str
- text += self.CodeFile.retrieveFunction.gettext().strip()
+ text += self.CodeFile.retrieveFunction.getanyText().strip()
text += "\n}\n\n"
text += "void __publish_%s(void)\n{\n"%location_str
- text += self.CodeFile.publishFunction.gettext().strip()
+ text += self.CodeFile.publishFunction.getanyText().strip()
text += "\n}\n\n"
Gen_Cfile_path = os.path.join(buildpath, "CFile_%s.c"%location_str)
--- a/controls/VariablePanel.py Thu Sep 26 20:47:36 2013 +0900
+++ b/controls/VariablePanel.py Fri Sep 27 09:32:39 2013 +0900
@@ -173,7 +173,7 @@
if var_class not in ["External", "InOut"]:
if self.Parent.Controler.IsEnumeratedType(var_type):
editor = wx.grid.GridCellChoiceEditor()
- editor.SetParameters(",".join(self.Parent.Controler.GetEnumeratedDataValues(var_type)))
+ editor.SetParameters(",".join([""] + self.Parent.Controler.GetEnumeratedDataValues(var_type)))
else:
editor = wx.grid.GridCellTextEditor()
renderer = wx.grid.GridCellStringRenderer()
@@ -618,7 +618,7 @@
if poutype != "function" and bodytype in ["ST", "IL"]:
return False
else:
- return name in self.Controler.GetFunctionBlockTypes(self.TagName)
+ return self.Controler.GetBlockType(name, debug=self.Debug) is not None
def RefreshView(self):
self.PouNames = self.Controler.GetProjectPouNames(self.Debug)
@@ -635,7 +635,7 @@
self.ReturnType.Clear()
for data_type in self.Controler.GetDataTypes(self.TagName, debug=self.Debug):
self.ReturnType.Append(data_type)
- returnType = self.Controler.GetEditedElementInterfaceReturnType(self.TagName)
+ returnType, (var_tree, dimensions) = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
description = self.Controler.GetPouDescription(words[1])
self.Values = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)
--- a/dialogs/BlockPreviewDialog.py Thu Sep 26 20:47:36 2013 +0900
+++ b/dialogs/BlockPreviewDialog.py Fri Sep 27 09:32:39 2013 +0900
@@ -177,7 +177,7 @@
# Add POU name to variable list if POU is a function
returntype = self.Controller.GetEditedElementInterfaceReturnType(
- self.TagName)
+ self.TagName)[0]
if returntype is not None:
self.VariableList[
self.Controller.GetEditedElementName(self.TagName)] = \
--- a/dialogs/FBDBlockDialog.py Thu Sep 26 20:47:36 2013 +0900
+++ b/dialogs/FBDBlockDialog.py Fri Sep 27 09:32:39 2013 +0900
@@ -160,6 +160,11 @@
# Extract block type defined in parameters
blocktype = values.get("type", None)
+ # Select block type in library panel
+ if blocktype is not None:
+ self.LibraryPanel.SelectTreeItem(blocktype,
+ values.get("inputs", None))
+
# Define regular expression for determine if block name is block
# default name
default_name_model = GetBlockTypeDefaultNameModel(blocktype)
@@ -186,11 +191,6 @@
if control is not None:
control.SetValue(value)
- # Select block type in library panel
- if blocktype is not None:
- self.LibraryPanel.SelectTreeItem(blocktype,
- values.get("inputs", None))
-
# Refresh preview panel
self.RefreshPreview()
--- a/editors/ConfTreeNodeEditor.py Thu Sep 26 20:47:36 2013 +0900
+++ b/editors/ConfTreeNodeEditor.py Fri Sep 27 09:32:39 2013 +0900
@@ -496,6 +496,8 @@
def GetChoiceCallBackFunction(self, choicectrl, path):
def OnChoiceChanged(event):
res = self.SetConfNodeParamsAttribute(path, choicectrl.GetStringSelection())
+ if res is None:
+ res = ""
choicectrl.SetStringSelection(res)
event.Skip()
return OnChoiceChanged
--- a/editors/LDViewer.py Thu Sep 26 20:47:36 2013 +0900
+++ b/editors/LDViewer.py Fri Sep 27 09:32:39 2013 +0900
@@ -487,7 +487,7 @@
for var in vars:
if var["Class"] != "Input" and var["Type"] == "BOOL":
varlist.append(var["Name"])
- returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
+ returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)[0]
if returntype == "BOOL":
varlist.append(self.Controler.GetEditedElementName(self.TagName))
dialog.SetVariables(varlist)
@@ -801,7 +801,7 @@
for var in vars:
if var["Class"] != "Input" and var["Type"] == "BOOL":
varlist.append(var["Name"])
- returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
+ returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)[0]
if returntype == "BOOL":
varlist.append(self.Controler.GetEditedElementName(self.TagName))
dialog.SetVariables(varlist)
--- a/editors/TextViewer.py Thu Sep 26 20:47:36 2013 +0900
+++ b/editors/TextViewer.py Fri Sep 27 09:32:39 2013 +0900
@@ -460,9 +460,8 @@
words = self.TagName.split("::")
self.Variables = self.GenerateVariableTree([(variable["Name"], variable["Type"], variable["Tree"]) for variable in self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)])
if self.Controler.GetEditedElementType(self.TagName, self.Debug)[1] == "function" or words[0] == "T" and self.TextSyntax == "IL":
- return_type = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
+ return_type, (var_tree, var_dimension) = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)
if return_type is not None:
- var_tree, var_dimension = self.Controler.GenerateVarTree(return_type, self.Debug)
self.Variables[words[-1].upper()] = self.GenerateVariableTree(var_tree)
else:
self.Variables[words[-1].upper()] = {}
--- a/editors/Viewer.py Thu Sep 26 20:47:36 2013 +0900
+++ b/editors/Viewer.py Fri Sep 27 09:32:39 2013 +0900
@@ -1074,7 +1074,7 @@
def RefreshView(self, variablepanel=True, selection=None):
EditorPanel.RefreshView(self, variablepanel)
- if self.TagName.split("::")[0] == "A":
+ if self.TagName.split("::")[0] == "A" and self.Debug:
self.AddDataConsumer("%s.Q" % self.InstancePath.upper(), self)
if self.ToolTipElement is not None:
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plcopen/Additional_Function_Blocks.xml Fri Sep 27 09:32:39 2013 +0900
@@ -0,0 +1,522 @@
+<?xml version='1.0' encoding='utf-8'?>
+<project xmlns:ns1="http://www.plcopen.org/xml/tc6_0201" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.plcopen.org/xml/tc6_0201">
+ <fileHeader companyName="Beremiz" productName="Additional Function Blocks Library" productVersion="1.0" creationDateTime="2013-09-09T09:56:11"/>
+ <contentHeader name="Standard Funtion Blocks" author="Laurent Bessard" modificationDateTime="2013-09-10T22:45:31">
+ <coordinateInfo>
+ <fbd>
+ <scaling x="0" y="0"/>
+ </fbd>
+ <ld>
+ <scaling x="0" y="0"/>
+ </ld>
+ <sfc>
+ <scaling x="0" y="0"/>
+ </sfc>
+ </coordinateInfo>
+ </contentHeader>
+ <types>
+ <dataTypes/>
+ <pous>
+ <pou name="RTC" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="IN">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[0 - current time, 1 - load time from PDT]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="PDT">
+ <type>
+ <DT/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Preset datetime]]></xhtml:p>
+ </documentation>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ <initialValue>
+ <simpleValue value="FALSE"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[Copy of IN]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="CDT">
+ <type>
+ <DT/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Datetime, current or relative to PDT]]></xhtml:p>
+ </documentation>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="PREV_IN">
+ <type>
+ <BOOL/>
+ </type>
+ <initialValue>
+ <simpleValue value="FALSE"/>
+ </initialValue>
+ </variable>
+ <variable name="OFFSET">
+ <type>
+ <TIME/>
+ </type>
+ </variable>
+ <variable name="CURRENT_TIME">
+ <type>
+ <DT/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[{__SET_VAR(data__->,CURRENT_TIME,__CURRENT_TIME)}
+
+ IF IN
+ THEN
+ IF NOT PREV_IN
+ THEN
+ OFFSET := PDT - CURRENT_TIME;
+ END_IF;
+
+ (* PDT + time since PDT was loaded *)
+ CDT := CURRENT_TIME + OFFSET;
+ ELSE
+ CDT := CURRENT_TIME;
+ END_IF;
+
+ Q := IN;
+ PREV_IN := IN;
+]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The real time clock has many uses including time stamping, setting dates and times of day in batch reports, in alarm messages and so on.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="INTEGRAL" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="RUN">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[1 = integrate, 0 = hold]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="R1">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Overriding reset]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="XIN">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Input variable]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="X0">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Initial value]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="CYCLE">
+ <type>
+ <TIME/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Sampling period]]></xhtml:p>
+ </documentation>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[NOT R1]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="XOUT">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Integrated output]]></xhtml:p>
+ </documentation>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[Q := NOT R1 ;
+IF R1 THEN XOUT := X0;
+ELSIF RUN THEN XOUT := XOUT + XIN * TIME_TO_REAL(CYCLE);
+END_IF;]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The integral function block integrates the value of input XIN over time.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="DERIVATIVE" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="RUN">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[0 = reset]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="XIN">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Input to be differentiated]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="CYCLE">
+ <type>
+ <TIME/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Sampling period]]></xhtml:p>
+ </documentation>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="XOUT">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Differentiated output]]></xhtml:p>
+ </documentation>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="X1">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ <variable name="X2">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ <variable name="X3">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[IF RUN THEN
+ XOUT := (3.0 * (XIN - X3) + X1 - X2)
+ / (10.0 * TIME_TO_REAL(CYCLE));
+ X3 := X2;
+ X2 := X1;
+ X1 := XIN;
+ELSE
+ XOUT := 0.0;
+ X1 := XIN;
+ X2 := XIN;
+ X3 := XIN;
+END_IF;]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The derivative function block produces an output XOUT proportional to the rate of change of the input XIN.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="PID" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="AUTO">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[0 - manual , 1 - automatic]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="PV">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Process variable]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="SP">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Set point]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="X0">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Manual output adjustment - Typically from transfer station]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="KP">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Proportionality constant]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="TR">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Reset time]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="TD">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Derivative time constant]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="CYCLE">
+ <type>
+ <TIME/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Sampling period]]></xhtml:p>
+ </documentation>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="XOUT">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="ERROR">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[PV - SP]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="ITERM">
+ <type>
+ <derived name="INTEGRAL"/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[FB for integral term]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="DTERM">
+ <type>
+ <derived name="DERIVATIVE"/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[FB for derivative term]]></xhtml:p>
+ </documentation>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[ERROR := PV - SP ;
+(*** Adjust ITERM so that XOUT := X0 when AUTO = 0 ***)
+ITERM(RUN := AUTO, R1 := NOT AUTO, XIN := ERROR,
+ X0 := TR * (X0 - ERROR), CYCLE := CYCLE);
+DTERM(RUN := AUTO, XIN := ERROR, CYCLE := CYCLE);
+XOUT := KP * (ERROR + ITERM.XOUT/TR + DTERM.XOUT*TD);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The PID (proportional, Integral, Derivative) function block provides the classical three term controller for closed loop control.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="RAMP" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="RUN">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[0 - track X0, 1 - ramp to/track X1]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="X0">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ <variable name="X1">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ <variable name="TR">
+ <type>
+ <TIME/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Ramp duration]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="CYCLE">
+ <type>
+ <TIME/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Sampling period]]></xhtml:p>
+ </documentation>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="BUSY">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[BUSY = 1 during ramping period]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="XOUT">
+ <type>
+ <REAL/>
+ </type>
+ <initialValue>
+ <simpleValue value="0.0"/>
+ </initialValue>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="XI">
+ <type>
+ <REAL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[Initial value]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="T">
+ <type>
+ <TIME/>
+ </type>
+ <initialValue>
+ <simpleValue value="T#0s"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[Elapsed time of ramp]]></xhtml:p>
+ </documentation>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[BUSY := RUN ;
+IF RUN THEN
+ IF T >= TR THEN
+ BUSY := 0;
+ XOUT := X1;
+ ELSE XOUT := XI + (X1-XI) * TIME_TO_REAL(T)
+ / TIME_TO_REAL(TR);
+ T := T + CYCLE;
+ END_IF;
+ELSE
+ XOUT := X0;
+ XI := X0;
+ T := T#0s;
+END_IF;]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The RAMP function block is modelled on example given in the standard.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="HYSTERESIS" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="XIN1">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ <variable name="XIN2">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ <variable name="EPS">
+ <type>
+ <REAL/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[IF Q THEN
+ IF XIN1 < (XIN2 - EPS) THEN
+ Q := 0;
+ END_IF;
+ELSIF XIN1 > (XIN2 + EPS) THEN
+ Q := 1;
+END_IF;]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The hysteresis function block provides a hysteresis boolean output driven by the difference of two floating point (REAL) inputs XIN1 and XIN2.]]></xhtml:p>
+ </documentation>
+ </pou>
+ </pous>
+ </types>
+ <instances>
+ <configurations/>
+ </instances>
+</project>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plcopen/Standard_Function_Blocks.xml Fri Sep 27 09:32:39 2013 +0900
@@ -0,0 +1,1469 @@
+<?xml version='1.0' encoding='utf-8'?>
+<project xmlns:ns1="http://www.plcopen.org/xml/tc6_0201" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.plcopen.org/xml/tc6_0201">
+ <fileHeader companyName="Beremiz" productName="Standard Function Blocks Library" productVersion="1.0" creationDateTime="2013-09-09T09:56:11"/>
+ <contentHeader name="Standard Funtion Blocks" author="Laurent Bessard" modificationDateTime="2013-09-09T10:58:13">
+ <coordinateInfo>
+ <fbd>
+ <scaling x="0" y="0"/>
+ </fbd>
+ <ld>
+ <scaling x="0" y="0"/>
+ </ld>
+ <sfc>
+ <scaling x="0" y="0"/>
+ </sfc>
+ </coordinateInfo>
+ </contentHeader>
+ <types>
+ <dataTypes/>
+ <pous>
+ <pou name="SR" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="S1">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q1">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[Q1 := S1 OR ((NOT R) AND Q1);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The SR bistable is a latch where the Set dominates.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="RS" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="S">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R1">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q1">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[Q1 := (NOT R1) AND (S OR Q1);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The RS bistable is a latch where the Reset dominates.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="SEMA" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CLAIM">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="RELEASE">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="BUSY">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="Q_INTERNAL">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[Q_INTERNAL := CLAIM OR ( Q_INTERNAL AND (NOT RELEASE));
+BUSY := Q_INTERNAL;]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The semaphore provides a mechanism to allow software elements mutually exclusive access to certain ressources.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="R_TRIG" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CLK">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars retain="true">
+ <variable name="M">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[Q := CLK AND NOT M;
+M := CLK;]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The output produces a single pulse when a rising edge is detected.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="F_TRIG" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CLK">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars retain="true">
+ <variable name="M">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[Q := NOT CLK AND NOT M;
+M := NOT CLK;]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The output produces a single pulse when a falling edge is detected.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTU" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <INT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <INT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CU_T(CU);
+IF R THEN CV := 0;
+ELSIF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+END_IF;
+Q := (CV >= PV);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-counter can be used to signal when a count has reached a maximum value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTU_DINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <DINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <DINT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CU_T(CU);
+IF R THEN CV := 0;
+ELSIF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+END_IF;
+Q := (CV >= PV);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-counter can be used to signal when a count has reached a maximum value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTU_LINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <LINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <LINT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CU_T(CU);
+IF R THEN CV := 0;
+ELSIF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+END_IF;
+Q := (CV >= PV);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-counter can be used to signal when a count has reached a maximum value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTU_UDINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <UDINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <UDINT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CU_T(CU);
+IF R THEN CV := 0;
+ELSIF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+END_IF;
+Q := (CV >= PV);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-counter can be used to signal when a count has reached a maximum value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTU_ULINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <ULINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <ULINT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CU_T(CU);
+IF R THEN CV := 0;
+ELSIF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+END_IF;
+Q := (CV >= PV);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-counter can be used to signal when a count has reached a maximum value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTD" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <INT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <INT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+IF LD THEN CV := PV;
+ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+END_IF;
+Q := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The down-counter can be used to signal when a count has reached zero, on counting down from a preset value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTD_DINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <DINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <DINT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+IF LD THEN CV := PV;
+ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+END_IF;
+Q := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The down-counter can be used to signal when a count has reached zero, on counting down from a preset value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTD_LINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <LINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <LINT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+IF LD THEN CV := PV;
+ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+END_IF;
+Q := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The down-counter can be used to signal when a count has reached zero, on counting down from a preset value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTD_UDINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <UDINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <UDINT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+IF LD THEN CV := PV;
+ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+END_IF;
+Q := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The down-counter can be used to signal when a count has reached zero, on counting down from a preset value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTD_ULINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <ULINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <ULINT/>
+ </type>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+IF LD THEN CV := PV;
+ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+END_IF;
+Q := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The down-counter can be used to signal when a count has reached zero, on counting down from a preset value.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTUD" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <INT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="QU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="QD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <INT/>
+ </type>
+ </variable>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+CU_T(CU);
+IF R THEN CV := 0;
+ELSIF LD THEN CV := PV;
+ELSE
+ IF NOT (CU_T.Q AND CD_T.Q) THEN
+ IF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+ ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+ END_IF;
+ END_IF;
+END_IF;
+QU := (CV >= PV);
+QD := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-down counter has two inputs CU and CD. It can be used to both count up on one input and down on the other.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTUD_DINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <DINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="QU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="QD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <DINT/>
+ </type>
+ </variable>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+CU_T(CU);
+IF R THEN CV := 0;
+ELSIF LD THEN CV := PV;
+ELSE
+ IF NOT (CU_T.Q AND CD_T.Q) THEN
+ IF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+ ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+ END_IF;
+ END_IF;
+END_IF;
+QU := (CV >= PV);
+QD := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-down counter has two inputs CU and CD. It can be used to both count up on one input and down on the other.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTUD_LINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <LINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="QU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="QD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <LINT/>
+ </type>
+ </variable>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+CU_T(CU);
+IF R THEN CV := 0;
+ELSIF LD THEN CV := PV;
+ELSE
+ IF NOT (CU_T.Q AND CD_T.Q) THEN
+ IF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+ ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+ END_IF;
+ END_IF;
+END_IF;
+QU := (CV >= PV);
+QD := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-down counter has two inputs CU and CD. It can be used to both count up on one input and down on the other.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTUD_UDINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <UDINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="QU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="QD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <UDINT/>
+ </type>
+ </variable>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+CU_T(CU);
+IF R THEN CV := 0;
+ELSIF LD THEN CV := PV;
+ELSE
+ IF NOT (CU_T.Q AND CD_T.Q) THEN
+ IF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+ ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+ END_IF;
+ END_IF;
+END_IF;
+QU := (CV >= PV);
+QD := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-down counter has two inputs CU and CD. It can be used to both count up on one input and down on the other.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="CTUD_ULINT" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="CU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="R">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="LD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="PV">
+ <type>
+ <ULINT/>
+ </type>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="QU">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="QD">
+ <type>
+ <BOOL/>
+ </type>
+ </variable>
+ <variable name="CV">
+ <type>
+ <ULINT/>
+ </type>
+ </variable>
+ <variable name="CD_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ <variable name="CU_T">
+ <type>
+ <derived name="R_TRIG"/>
+ </type>
+ </variable>
+ </outputVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[CD_T(CD);
+CU_T(CU);
+IF R THEN CV := 0;
+ELSIF LD THEN CV := PV;
+ELSE
+ IF NOT (CU_T.Q AND CD_T.Q) THEN
+ IF CU_T.Q AND (CV < PV)
+ THEN CV := CV+1;
+ ELSIF CD_T.Q AND (CV > 0)
+ THEN CV := CV-1;
+ END_IF;
+ END_IF;
+END_IF;
+QU := (CV >= PV);
+QD := (CV <= 0);]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The up-down counter has two inputs CU and CD. It can be used to both count up on one input and down on the other.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="TP" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="IN">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[first input parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="PT">
+ <type>
+ <TIME/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[second input parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ <initialValue>
+ <simpleValue value="FALSE"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[first output parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="ET">
+ <type>
+ <TIME/>
+ </type>
+ <initialValue>
+ <simpleValue value="T#0s"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[second output parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="STATE">
+ <type>
+ <SINT/>
+ </type>
+ <initialValue>
+ <simpleValue value="0"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[internal state: 0-reset, 1-counting, 2-set]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="PREV_IN">
+ <type>
+ <BOOL/>
+ </type>
+ <initialValue>
+ <simpleValue value="FALSE"/>
+ </initialValue>
+ </variable>
+ <variable name="CURRENT_TIME">
+ <type>
+ <TIME/>
+ </type>
+ </variable>
+ <variable name="START_TIME">
+ <type>
+ <TIME/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[{__SET_VAR(data__->,CURRENT_TIME,__CURRENT_TIME)}
+
+IF ((STATE = 0) AND NOT(PREV_IN) AND IN) (* found rising edge on IN *)
+THEN
+ (* start timer... *)
+ STATE := 1;
+ Q := TRUE;
+ START_TIME := CURRENT_TIME;
+
+ELSIF (STATE = 1)
+THEN
+ IF ((START_TIME + PT) <= CURRENT_TIME)
+ THEN
+ STATE := 2;
+ Q := FALSE;
+ ET := PT;
+ ELSE
+ ET := CURRENT_TIME - START_TIME;
+ END_IF;
+END_IF;
+
+IF ((STATE = 2) AND NOT(IN))
+THEN
+ ET := T#0s;
+ STATE := 0;
+END_IF;
+
+PREV_IN := IN;
+]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The pulse timer can be used to generate output pulses of a given time duration.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="TON" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="IN">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[first input parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="PT">
+ <type>
+ <TIME/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[second input parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ <initialValue>
+ <simpleValue value="FALSE"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[first output parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="ET">
+ <type>
+ <TIME/>
+ </type>
+ <initialValue>
+ <simpleValue value="T#0s"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[second output parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="STATE">
+ <type>
+ <SINT/>
+ </type>
+ <initialValue>
+ <simpleValue value="0"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[internal state: 0-reset, 1-counting, 2-set]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="PREV_IN">
+ <type>
+ <BOOL/>
+ </type>
+ <initialValue>
+ <simpleValue value="FALSE"/>
+ </initialValue>
+ </variable>
+ <variable name="CURRENT_TIME">
+ <type>
+ <TIME/>
+ </type>
+ </variable>
+ <variable name="START_TIME">
+ <type>
+ <TIME/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[{__SET_VAR(data__->,CURRENT_TIME,__CURRENT_TIME)}
+
+IF ((STATE = 0) AND NOT(PREV_IN) AND IN) (* found rising edge on IN *)
+THEN
+ (* start timer... *)
+ STATE := 1;
+ Q := FALSE;
+ START_TIME := CURRENT_TIME;
+
+ELSE
+ (* STATE is 1 or 2 !! *)
+ IF (NOT(IN))
+ THEN
+ ET := T#0s;
+ Q := FALSE;
+ STATE := 0;
+
+ ELSIF (STATE = 1)
+ THEN
+ IF ((START_TIME + PT) <= CURRENT_TIME)
+ THEN
+ STATE := 2;
+ Q := TRUE;
+ ET := PT;
+ ELSE
+ ET := CURRENT_TIME - START_TIME;
+ END_IF;
+ END_IF;
+
+END_IF;
+
+PREV_IN := IN;
+]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The on-delay timer can be used to delay setting an output true, for fixed period after an input becomes true.]]></xhtml:p>
+ </documentation>
+ </pou>
+ <pou name="TOF" pouType="functionBlock">
+ <interface>
+ <inputVars>
+ <variable name="IN">
+ <type>
+ <BOOL/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[first input parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="PT">
+ <type>
+ <TIME/>
+ </type>
+ <documentation>
+ <xhtml:p><![CDATA[second input parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ </inputVars>
+ <outputVars>
+ <variable name="Q">
+ <type>
+ <BOOL/>
+ </type>
+ <initialValue>
+ <simpleValue value="FALSE"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[first output parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="ET">
+ <type>
+ <TIME/>
+ </type>
+ <initialValue>
+ <simpleValue value="T#0s"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[second output parameter]]></xhtml:p>
+ </documentation>
+ </variable>
+ </outputVars>
+ <localVars>
+ <variable name="STATE">
+ <type>
+ <SINT/>
+ </type>
+ <initialValue>
+ <simpleValue value="0"/>
+ </initialValue>
+ <documentation>
+ <xhtml:p><![CDATA[internal state: 0-reset, 1-counting, 2-set]]></xhtml:p>
+ </documentation>
+ </variable>
+ <variable name="PREV_IN">
+ <type>
+ <BOOL/>
+ </type>
+ <initialValue>
+ <simpleValue value="FALSE"/>
+ </initialValue>
+ </variable>
+ <variable name="CURRENT_TIME">
+ <type>
+ <TIME/>
+ </type>
+ </variable>
+ <variable name="START_TIME">
+ <type>
+ <TIME/>
+ </type>
+ </variable>
+ </localVars>
+ </interface>
+ <body>
+ <ST>
+ <xhtml:p><![CDATA[{__SET_VAR(data__->,CURRENT_TIME,__CURRENT_TIME)}
+
+IF ((STATE = 0) AND PREV_IN AND NOT(IN)) (* found falling edge on IN *)
+THEN
+ (* start timer... *)
+ STATE := 1;
+ START_TIME := CURRENT_TIME;
+
+ELSE
+ (* STATE is 1 or 2 !! *)
+ IF (IN)
+ THEN
+ ET := T#0s;
+ STATE := 0;
+
+ ELSIF (STATE = 1)
+ THEN
+ IF ((START_TIME + PT) <= CURRENT_TIME)
+ THEN
+ STATE := 2;
+ ET := PT;
+ ELSE
+ ET := CURRENT_TIME - START_TIME;
+ END_IF;
+ END_IF;
+
+END_IF;
+
+Q := IN OR (STATE = 1);
+PREV_IN := IN;
+]]></xhtml:p>
+ </ST>
+ </body>
+ <documentation>
+ <xhtml:p><![CDATA[The off-delay timer can be used to delay setting an output false, for fixed period after input goes false.]]></xhtml:p>
+ </documentation>
+ </pou>
+ </pous>
+ </types>
+ <instances>
+ <configurations/>
+ </instances>
+</project>
--- a/plcopen/__init__.py Thu Sep 26 20:47:36 2013 +0900
+++ b/plcopen/__init__.py Fri Sep 27 09:32:39 2013 +0900
@@ -25,9 +25,7 @@
# Package initialisation
# plcopen module dynamically creates its classes
-import plcopen
-for classname, cls in plcopen.PLCOpenClasses.items():
- plcopen.__dict__[classname] = cls
-from plcopen import VarOrder, ElementNameToClass, rect
+from plcopen import PLCOpenParser, LoadProject, SaveProject, LoadPou, \
+ LoadPouInstances, VarOrder, QualifierList, rect
from structures import *
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plcopen/instance_tagname.xslt Fri Sep 27 09:32:39 2013 +0900
@@ -0,0 +1,205 @@
+<xsl:stylesheet version="1.0"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+ xmlns:ppx="http://www.plcopen.org/xml/tc6_0201"
+ xmlns:xhtml="http://www.w3.org/1999/xhtml"
+ xmlns:ns="instance_tagname_ns"
+ extension-element-prefixes="ns"
+ exclude-result-prefixes="ns">
+ <xsl:param name="instance_path"/>
+ <xsl:template name="element_name">
+ <xsl:param name="path"/>
+ <xsl:choose>
+ <xsl:when test="contains($path,'.')">
+ <xsl:value-of select="substring-before($path,'.')"/>
+ </xsl:when>
+ <xsl:otherwise>
+ <xsl:value-of select="$path"/>
+ </xsl:otherwise>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template name="next_path">
+ <xsl:param name="path"/>
+ <xsl:choose>
+ <xsl:when test="contains($path,'.')">
+ <xsl:value-of select="substring-after($path,'.')"/>
+ </xsl:when>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template match="ppx:project">
+ <xsl:variable name="config_name">
+ <xsl:call-template name="element_name">
+ <xsl:with-param name="path" select="$instance_path"/>
+ </xsl:call-template>
+ </xsl:variable>
+ <xsl:apply-templates select="ppx:instances/ppx:configurations/ppx:configuration[@name=$config_name]">
+ <xsl:with-param name="element_path">
+ <xsl:call-template name="next_path">
+ <xsl:with-param name="path" select="$instance_path"/>
+ </xsl:call-template>
+ </xsl:with-param>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="ppx:configuration">
+ <xsl:param name="element_path"/>
+ <xsl:choose>
+ <xsl:when test="$element_path!=''">
+ <xsl:variable name="child_name">
+ <xsl:call-template name="element_name">
+ <xsl:with-param name="path" select="$element_path"/>
+ </xsl:call-template>
+ </xsl:variable>
+ <xsl:apply-templates select="ppx:resource[@name=$child_name] | ppx:globalVars/ppx:variable[@name=$child_name]/ppx:type/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="element_path">
+ <xsl:call-template name="next_path">
+ <xsl:with-param name="path" select="$element_path"/>
+ </xsl:call-template>
+ </xsl:with-param>
+ </xsl:apply-templates>
+ </xsl:when>
+ <xsl:otherwise>
+ <ns:config_tagname>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@name"/>
+ </xsl:attribute>
+ </ns:config_tagname>
+ </xsl:otherwise>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template match="ppx:resource">
+ <xsl:param name="element_path"/>
+ <xsl:choose>
+ <xsl:when test="$element_path!=''">
+ <xsl:variable name="child_name">
+ <xsl:call-template name="element_name">
+ <xsl:with-param name="path" select="$element_path"/>
+ </xsl:call-template>
+ </xsl:variable>
+ <xsl:apply-templates select="ppx:pouInstance[@name=$child_name] | ppx:task/ppx:pouInstance[@name=$child_name] | ppx:globalVars/ppx:variable[@name=$child_name]/ppx:type/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="element_path">
+ <xsl:call-template name="next_path">
+ <xsl:with-param name="path" select="$element_path"/>
+ </xsl:call-template>
+ </xsl:with-param>
+ </xsl:apply-templates>
+ </xsl:when>
+ <xsl:otherwise>
+ <ns:resource_tagname>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@name"/>
+ </xsl:attribute>
+ <xsl:attribute name="config_name">
+ <xsl:value-of select="ancestor::ppx:configuration/@name"/>
+ </xsl:attribute>
+ </ns:resource_tagname>
+ </xsl:otherwise>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template match="ppx:pouInstance">
+ <xsl:param name="element_path"/>
+ <ns:instance_definition>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@typeName"/>
+ </xsl:attribute>
+ <xsl:attribute name="path">
+ <xsl:value-of select="$element_path"/>
+ </xsl:attribute>
+ </ns:instance_definition>
+ </xsl:template>
+ <xsl:template match="ppx:pou">
+ <xsl:param name="element_path"/>
+ <xsl:variable name="child_name">
+ <xsl:call-template name="element_name">
+ <xsl:with-param name="path" select="$element_path"/>
+ </xsl:call-template>
+ </xsl:variable>
+ <xsl:apply-templates select="ppx:interface/*/ppx:variable[@name=$child_name]/ppx:type/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="element_path">
+ <xsl:call-template name="next_path">
+ <xsl:with-param name="path" select="$element_path"/>
+ </xsl:call-template>
+ </xsl:with-param>
+ </xsl:apply-templates>
+ <xsl:apply-templates select="ppx:actions/ppx:action[@name=$child_name]"/>
+ <xsl:apply-templates select="ppx:transitions/ppx:transition[@name=$child_name]"/>
+ </xsl:template>
+ <xsl:template match="ppx:action">
+ <ns:action_tagname>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@name"/>
+ </xsl:attribute>
+ <xsl:attribute name="pou_name">
+ <xsl:value-of select="ancestor::ppx:pou/@name"/>
+ </xsl:attribute>
+ </ns:action_tagname>
+ </xsl:template>
+ <xsl:template match="ppx:transition">
+ <ns:transition_tagname>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@name"/>
+ </xsl:attribute>
+ <xsl:attribute name="pou_name">
+ <xsl:value-of select="ancestor::ppx:pou/@name"/>
+ </xsl:attribute>
+ </ns:transition_tagname>
+ </xsl:template>
+ <xsl:template name="ppx:dataType">
+ <xsl:param name="element_path"/>
+ <xsl:apply-templates select="ppx:baseType/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="element_path" select="element_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="ppx:derived">
+ <xsl:param name="element_path"/>
+ <ns:instance_definition>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@name"/>
+ </xsl:attribute>
+ <xsl:attribute name="path">
+ <xsl:value-of select="$element_path"/>
+ </xsl:attribute>
+ </ns:instance_definition>
+ </xsl:template>
+ <xsl:template match="array">
+ <xsl:param name="element_path"/>
+ <xsl:apply-templates select="ppx:baseType/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="element_path" select="element_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="struct">
+ <xsl:param name="element_path"/>
+ <xsl:variable name="child_name">
+ <xsl:call-template name="element_name">
+ <xsl:with-param name="path" select="$element_path"/>
+ </xsl:call-template>
+ </xsl:variable>
+ <xsl:variable name="next_child_path">
+ <xsl:call-template name="next_path">
+ <xsl:with-param name="path" select="$element_path"/>
+ </xsl:call-template>
+ </xsl:variable>
+ <xsl:apply-templates select="ppx:variable[@name=$child_name]/ppx:type/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="element_path" select="element_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="pou_instance">
+ <xsl:choose>
+ <xsl:when test="@pou_path!=''">
+ <xsl:apply-templates>
+ <xsl:with-param name="element_path" select="@pou_path"/>
+ </xsl:apply-templates>
+ </xsl:when>
+ <xsl:otherwise>
+ <ns:pou_tagname>
+ <xsl:attribute name="name">
+ <xsl:value-of select="ppx:pou/@name"/>
+ </xsl:attribute>
+ </ns:pou_tagname>
+ </xsl:otherwise>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template match="datatype_instance">
+ <xsl:apply-templates>
+ <xsl:with-param name="element_path" select="@datatype_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+</xsl:stylesheet>
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plcopen/instances_path.xslt Fri Sep 27 09:32:39 2013 +0900
@@ -0,0 +1,137 @@
+<xsl:stylesheet version="1.0"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+ xmlns:ppx="http://www.plcopen.org/xml/tc6_0201"
+ xmlns:ns="instances_ns"
+ extension-element-prefixes="ns"
+ exclude-result-prefixes="ns">
+ <xsl:param name="instance_type"/>
+ <xsl:template match="ppx:project">
+ <instances>
+ <xsl:apply-templates select="ppx:instances/ppx:configurations/ppx:configuration"/>
+ </instances>
+ </xsl:template>
+ <xsl:template match="ppx:configuration">
+ <xsl:apply-templates select="ppx:globalVars/ppx:variable[ppx:type/ppx:derived]">
+ <xsl:with-param name="parent_path" select="@name"/>
+ </xsl:apply-templates>
+ <xsl:apply-templates select="ppx:resource">
+ <xsl:with-param name="parent_path" select="@name"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="ppx:resource">
+ <xsl:param name="parent_path"/>
+ <xsl:variable name="resource_path">
+ <xsl:value-of select="$parent_path"/>
+ <xsl:text>.</xsl:text>
+ <xsl:value-of select="@name"/>
+ </xsl:variable>
+ <xsl:apply-templates select="ppx:globalVars/ppx:variable[ppx:type/ppx:derived]">
+ <xsl:with-param name="parent_path" select="$resource_path"/>
+ </xsl:apply-templates>
+ <xsl:apply-templates select="ppx:pouInstance | ppx:task/ppx:pouInstance">
+ <xsl:with-param name="parent_path" select="$resource_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="ppx:pouInstance">
+ <xsl:param name="parent_path"/>
+ <xsl:variable name="pou_instance_path">
+ <xsl:value-of select="$parent_path"/>
+ <xsl:text>.</xsl:text>
+ <xsl:value-of select="@name"/>
+ </xsl:variable>
+ <xsl:choose>
+ <xsl:when test="@typeName=$instance_type">
+ <instance>
+ <xsl:attribute name="path">
+ <xsl:value-of select="$pou_instance_path"/>
+ </xsl:attribute>
+ </instance>
+ </xsl:when>
+ <xsl:otherwise>
+ <ns:instance_definition>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@typeName"/>
+ </xsl:attribute>
+ <xsl:attribute name="path">
+ <xsl:value-of select="$pou_instance_path"/>
+ </xsl:attribute>
+ </ns:instance_definition>
+ </xsl:otherwise>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template match="ppx:pou">
+ <xsl:param name="instance_path"/>
+ <xsl:apply-templates select="ppx:interface/*/ppx:variable[ppx:type/ppx:derived]">
+ <xsl:with-param name="parent_path" select="$instance_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="ppx:dataType">
+ <xsl:param name="instance_path"/>
+ <xsl:apply-templates select="ppx:baseType/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="parent_path" select="$instance_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="ppx:variable">
+ <xsl:param name="parent_path"/>
+ <xsl:variable name="variable_path">
+ <xsl:value-of select="$parent_path"/>
+ <xsl:text>.</xsl:text>
+ <xsl:value-of select="@name"/>
+ </xsl:variable>
+ <xsl:apply-templates select="ppx:type/ppx:derived">
+ <xsl:with-param name="variable_path" select="$variable_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="ppx:derived">
+ <xsl:param name="variable_path"/>
+ <xsl:choose>
+ <xsl:when test="@name=$instance_type">
+ <instance>
+ <xsl:attribute name="path">
+ <xsl:value-of select="$variable_path"/>
+ </xsl:attribute>
+ </instance>
+ </xsl:when>
+ <xsl:otherwise>
+ <ns:instance_definition>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@name"/>
+ </xsl:attribute>
+ <xsl:attribute name="path">
+ <xsl:value-of select="$variable_path"/>
+ </xsl:attribute>
+ </ns:instance_definition>
+ </xsl:otherwise>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template name="ppx:struct">
+ <xsl:param name="variable_path"/>
+ <xsl:for-each select="ppx:variable[ppx:type/ppx:derived or ppx:type/ppx:struct or ppx:type/ppx:array]">
+ <xsl:variable name="element_path">
+ <xsl:value-of select="$variable_path"/>
+ <xsl:text>.</xsl:text>
+ <xsl:value-of select="@name"/>
+ </xsl:variable>
+ <xsl:apply-templates select="ppx:type/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="variable_path" select="$element_path"/>
+ </xsl:apply-templates>
+ </xsl:for-each>
+ </xsl:template>
+ <xsl:template name="ppx:array">
+ <xsl:param name="variable_path"/>
+ <xsl:apply-templates select="ppx:baseType/*[self::ppx:derived or self::ppx:struct or self::ppx:array]">
+ <xsl:with-param name="variable_path" select="$variable_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="pou_instance">
+ <xsl:apply-templates>
+ <xsl:with-param name="instance_path" select="@pou_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="datatype_instance">
+ <xsl:apply-templates>
+ <xsl:with-param name="instance_path" select="@datatype_path"/>
+ </xsl:apply-templates>
+ </xsl:template>
+ <xsl:template match="text()"/>
+</xsl:stylesheet>
\ No newline at end of file
--- a/plcopen/plcopen.py Thu Sep 26 20:47:36 2013 +0900
+++ b/plcopen/plcopen.py Fri Sep 27 09:32:39 2013 +0900
@@ -23,10 +23,9 @@
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from xmlclass import *
-from structures import *
from types import *
import os, re
-from collections import OrderedDict
+from lxml import etree
"""
Dictionary that makes the relation between var names in plcopen and displayed values
"""
@@ -122,14 +121,84 @@
result = criteria["pattern"].search(text, result.end())
return test_result
-PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))
-
-ElementNameToClass = {}
-
-cls = PLCOpenClasses.get("formattedText", None)
+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 = """
+<project xmlns:ns1="http://www.plcopen.org/xml/tc6_0201"
+ xmlns:xhtml="http://www.w3.org/1999/xhtml"
+ xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+ xmlns="http://www.plcopen.org/xml/tc6_0201">
+ <fileHeader companyName="" productName="" productVersion=""
+ creationDateTime="1970-01-01T00:00:00"/>
+ <contentHeader name="paste_project">
+ <coordinateInfo>
+ <fbd><scaling x="0" y="0"/></fbd>
+ <ld><scaling x="0" y="0"/></ld>
+ <sfc><scaling x="0" y="0"/></sfc>
+ </coordinateInfo>
+ </contentHeader>
+ <types>
+ <dataTypes/>
+ <pous>%s</pous>
+ </types>
+ <instances>
+ <configurations/>
+ </instances>
+</project>
+"""
+
+def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):
+ return LOAD_POU_PROJECT_TEMPLATE % """
+<pou name="paste_pou" pouType="program">
+ <body>
+ <%(body_type)s>%%s</%(body_type)s>
+ </body>
+</pou>""" % locals()
+
+def LoadProject(filepath):
+ project_file = open(filepath)
+ project_xml = project_file.read().replace(
+ "http://www.plcopen.org/xml/tc6.xsd",
+ "http://www.plcopen.org/xml/tc6_0201")
+ for cre, repl in [
+ (re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),
+ (re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:
+ project_xml = cre.sub(repl, project_xml)
+ project_file.close()
+
+ return etree.fromstring(project_xml, PLCOpenParser)
+
+project_pou_xpath = PLCOpen_XPath("/ppx:project/ppx:types/ppx:pous/ppx:pou")
+def LoadPou(xml_string):
+ root = etree.fromstring(
+ LOAD_POU_PROJECT_TEMPLATE % xml_string,
+ PLCOpenParser)
+ return project_pou_xpath(root)[0]
+
+project_pou_instances_xpath = {
+ body_type: PLCOpen_XPath(
+ "/ppx:project/ppx:types/ppx:pous/ppx:pou[@name='paste_pou']/ppx:body/ppx:%s/*" % body_type)
+ for body_type in ["FBD", "LD", "SFC"]}
+def LoadPouInstances(xml_string, body_type):
+ root = etree.fromstring(
+ LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string,
+ PLCOpenParser)
+ return project_pou_instances_xpath[body_type](root)
+
+def SaveProject(project, filepath):
+ project_file = open(filepath, 'w')
+ project_file.write(etree.tostring(
+ project,
+ pretty_print=True,
+ xml_declaration=True,
+ encoding='utf-8'))
+ project_file.close()
+
+cls = PLCOpenParser.GetElementClass("formattedText")
if cls:
def updateElementName(self, old_name, new_name):
- text = self.text
+ text = self.getanyText()
index = text.find(old_name)
while index != -1:
if index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_"):
@@ -139,11 +208,11 @@
else:
text = text[:index] + new_name + text[index + len(old_name):]
index = text.find(old_name, index + len(new_name))
- self.text = text
+ self.setanyText(text)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- text = self.text
+ text = self.getanyText()
startpos = 0
result = address_model.search(text, startpos)
while result is not None:
@@ -151,12 +220,12 @@
new_address = groups[0] + new_leading + groups[2]
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
+ result = address_model.search(text, startpos)
+ self.setanyText(text)
setattr(cls, "updateElementAddress", updateElementAddress)
def hasblock(self, block_type):
- text = self.text.upper()
+ text = self.getanyText().upper()
index = text.find(block_type.upper())
while index != -1:
if (not (index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_")) and
@@ -167,17 +236,11 @@
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 = PLCOpenClasses.get("project", None)
-if cls:
- cls.singleLineAttributes = False
- cls.EnumeratedDataTypeValues = {}
- cls.CustomDataTypeRange = {}
- cls.CustomTypeHierarchy = {}
- cls.ElementUsingTree = {}
- cls.CustomBlockTypes = OrderedDict()
+cls = PLCOpenParser.GetElementClass("project")
+if cls:
def setname(self, name):
self.contentHeader.setname(name)
@@ -188,522 +251,219 @@
setattr(cls, "getname", getname)
def getfileHeader(self):
- fileheader = {}
- for name, value in [("companyName", self.fileHeader.getcompanyName()),
- ("companyURL", self.fileHeader.getcompanyURL()),
- ("productName", self.fileHeader.getproductName()),
- ("productVersion", self.fileHeader.getproductVersion()),
- ("productRelease", self.fileHeader.getproductRelease()),
- ("creationDateTime", self.fileHeader.getcreationDateTime()),
- ("contentDescription", self.fileHeader.getcontentDescription())]:
+ fileheader_obj = self.fileHeader
+ return {
+ attr: value if value is not None else ""
+ for attr, value in [
+ ("companyName", fileheader_obj.getcompanyName()),
+ ("companyURL", fileheader_obj.getcompanyURL()),
+ ("productName", fileheader_obj.getproductName()),
+ ("productVersion", fileheader_obj.getproductVersion()),
+ ("productRelease", fileheader_obj.getproductRelease()),
+ ("creationDateTime", fileheader_obj.getcreationDateTime()),
+ ("contentDescription", fileheader_obj.getcontentDescription())]
+ }
+ setattr(cls, "getfileHeader", getfileHeader)
+
+ def setfileHeader(self, fileheader):
+ fileheader_obj = self.fileHeader
+ for attr in ["companyName", "companyURL", "productName",
+ "productVersion", "productRelease", "creationDateTime",
+ "contentDescription"]:
+ value = fileheader.get(attr)
if value is not None:
- fileheader[name] = value
- else:
- fileheader[name] = ""
- return fileheader
- setattr(cls, "getfileHeader", getfileHeader)
-
- def setfileHeader(self, fileheader):
- if fileheader.has_key("companyName"):
- self.fileHeader.setcompanyName(fileheader["companyName"])
- if fileheader.has_key("companyURL"):
- self.fileHeader.setcompanyURL(fileheader["companyURL"])
- if fileheader.has_key("productName"):
- self.fileHeader.setproductName(fileheader["productName"])
- if fileheader.has_key("productVersion"):
- self.fileHeader.setproductVersion(fileheader["productVersion"])
- if fileheader.has_key("productRelease"):
- self.fileHeader.setproductRelease(fileheader["productRelease"])
- if fileheader.has_key("creationDateTime"):
- self.fileHeader.setcreationDateTime(fileheader["creationDateTime"])
- if fileheader.has_key("contentDescription"):
- self.fileHeader.setcontentDescription(fileheader["contentDescription"])
+ setattr(fileheader_obj, attr, value)
setattr(cls, "setfileHeader", setfileHeader)
def getcontentHeader(self):
- contentheader = {}
- for name, value in [("projectName", self.contentHeader.getname()),
- ("projectVersion", self.contentHeader.getversion()),
- ("modificationDateTime", self.contentHeader.getmodificationDateTime()),
- ("organization", self.contentHeader.getorganization()),
- ("authorName", self.contentHeader.getauthor()),
- ("language", self.contentHeader.getlanguage())]:
- if value is not None:
- contentheader[name] = value
- else:
- contentheader[name] = ""
+ contentheader_obj = self.contentHeader
+ contentheader = {
+ attr: value if value is not None else ""
+ for attr, value in [
+ ("projectName", contentheader_obj.getname()),
+ ("projectVersion", contentheader_obj.getversion()),
+ ("modificationDateTime", contentheader_obj.getmodificationDateTime()),
+ ("organization", contentheader_obj.getorganization()),
+ ("authorName", contentheader_obj.getauthor()),
+ ("language", contentheader_obj.getlanguage())]
+ }
contentheader["pageSize"] = self.contentHeader.getpageSize()
contentheader["scaling"] = self.contentHeader.getscaling()
return contentheader
setattr(cls, "getcontentHeader", getcontentHeader)
def setcontentHeader(self, contentheader):
- if contentheader.has_key("projectName"):
- self.contentHeader.setname(contentheader["projectName"])
- if contentheader.has_key("projectVersion"):
- self.contentHeader.setversion(contentheader["projectVersion"])
- if contentheader.has_key("modificationDateTime"):
- self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"])
- if contentheader.has_key("organization"):
- self.contentHeader.setorganization(contentheader["organization"])
- if contentheader.has_key("authorName"):
- self.contentHeader.setauthor(contentheader["authorName"])
- if contentheader.has_key("language"):
- self.contentHeader.setlanguage(contentheader["language"])
- if contentheader.has_key("pageSize"):
- self.contentHeader.setpageSize(*contentheader["pageSize"])
- if contentheader.has_key("scaling"):
- self.contentHeader.setscaling(contentheader["scaling"])
+ contentheader_obj = self.contentHeader
+ for attr, value in contentheader.iteritems():
+ func = {"projectName": contentheader_obj.setname,
+ "projectVersion": contentheader_obj.setversion,
+ "authorName": contentheader_obj.setauthor,
+ "pageSize": lambda v: contentheader_obj.setpageSize(*v),
+ "scaling": contentheader_obj.setscaling}.get(attr)
+ if func is not None:
+ func(value)
+ elif attr in ["modificationDateTime", "organization", "language"]:
+ setattr(contentheader_obj, attr, value)
setattr(cls, "setcontentHeader", setcontentHeader)
- def getdataTypes(self):
- return self.types.getdataTypeElements()
+ def gettypeElementFunc(element_type):
+ elements_xpath = PLCOpen_XPath(
+ "ppx:types/ppx:%(element_type)ss/ppx:%(element_type)s[@name=$name]" % locals())
+ def gettypeElement(self, name):
+ elements = elements_xpath(self, name=name)
+ if len(elements) == 1:
+ return elements[0]
+ return None
+ return gettypeElement
+
+ datatypes_xpath = PLCOpen_XPath("ppx:types/ppx:dataTypes/ppx:dataType")
+ filtered_datatypes_xpath = PLCOpen_XPath(
+ "ppx:types/ppx:dataTypes/ppx:dataType[@name!=$exclude]")
+ def getdataTypes(self, exclude=None):
+ if exclude is not None:
+ return filtered_datatypes_xpath(self, exclude=exclude)
+ return datatypes_xpath(self)
setattr(cls, "getdataTypes", getdataTypes)
- def getdataType(self, name):
- return self.types.getdataTypeElement(name)
- setattr(cls, "getdataType", getdataType)
+ setattr(cls, "getdataType", gettypeElementFunc("dataType"))
def appenddataType(self, name):
- if self.CustomTypeHierarchy.has_key(name):
+ if self.getdataType(name) is not None:
raise ValueError, "\"%s\" Data Type already exists !!!"%name
self.types.appenddataTypeElement(name)
- self.AddCustomDataType(self.getdataType(name))
setattr(cls, "appenddataType", appenddataType)
def insertdataType(self, index, datatype):
self.types.insertdataTypeElement(index, datatype)
- self.AddCustomDataType(datatype)
setattr(cls, "insertdataType", insertdataType)
def removedataType(self, name):
self.types.removedataTypeElement(name)
- self.RefreshDataTypeHierarchy()
- self.RefreshElementUsingTree()
setattr(cls, "removedataType", removedataType)
- def getpous(self):
- return self.types.getpouElements()
+ def getpous(self, exclude=None, filter=[]):
+ return self.xpath(
+ "ppx:types/ppx:pous/ppx:pou%s%s" %
+ (("[@name!='%s']" % exclude) if exclude is not None else '',
+ ("[%s]" % " or ".join(
+ map(lambda x: "@pouType='%s'" % x, filter)))
+ if len(filter) > 0 else ""),
+ namespaces=PLCOpenParser.NSMAP)
setattr(cls, "getpous", getpous)
- def getpou(self, name):
- return self.types.getpouElement(name)
- setattr(cls, "getpou", getpou)
+ setattr(cls, "getpou", gettypeElementFunc("pou"))
def appendpou(self, name, pou_type, body_type):
self.types.appendpouElement(name, pou_type, body_type)
- self.AddCustomBlockType(self.getpou(name))
setattr(cls, "appendpou", appendpou)
def insertpou(self, index, pou):
self.types.insertpouElement(index, pou)
- self.AddCustomBlockType(pou)
setattr(cls, "insertpou", insertpou)
def removepou(self, name):
self.types.removepouElement(name)
- self.RefreshCustomBlockTypes()
- self.RefreshElementUsingTree()
setattr(cls, "removepou", removepou)
+ configurations_xpath = PLCOpen_XPath(
+ "ppx:instances/ppx:configurations/ppx:configuration")
def getconfigurations(self):
- configurations = self.instances.configurations.getconfiguration()
- if configurations:
- return configurations
- return []
+ return configurations_xpath(self)
setattr(cls, "getconfigurations", getconfigurations)
+ configuration_xpath = PLCOpen_XPath(
+ "ppx:instances/ppx:configurations/ppx:configuration[@name=$name]")
def getconfiguration(self, name):
- for configuration in self.instances.configurations.getconfiguration():
- if configuration.getname() == name:
- return configuration
+ configurations = configuration_xpath(self, name=name)
+ if len(configurations) == 1:
+ return configurations[0]
return None
setattr(cls, "getconfiguration", getconfiguration)
def addconfiguration(self, name):
- for configuration in self.instances.configurations.getconfiguration():
- if configuration.getname() == name:
- raise ValueError, _("\"%s\" configuration already exists !!!")%name
- new_configuration = PLCOpenClasses["configurations_configuration"]()
+ if self.getconfiguration(name) is not None:
+ raise ValueError, _("\"%s\" configuration already exists !!!") % name
+ new_configuration = PLCOpenParser.CreateElement("configuration", "configurations")
new_configuration.setname(name)
self.instances.configurations.appendconfiguration(new_configuration)
setattr(cls, "addconfiguration", addconfiguration)
def removeconfiguration(self, name):
- found = False
- for idx, configuration in enumerate(self.instances.configurations.getconfiguration()):
- if configuration.getname() == name:
- self.instances.configurations.removeconfiguration(idx)
- found = True
- break
- if not found:
- raise ValueError, ("\"%s\" configuration doesn't exist !!!")%name
+ configuration = self.getconfiguration(name)
+ if configuration is None:
+ raise ValueError, ("\"%s\" configuration doesn't exist !!!") % name
+ self.instances.configurations.remove(configuration)
setattr(cls, "removeconfiguration", removeconfiguration)
-
+
+ resources_xpath = PLCOpen_XPath(
+ "ppx:instances/ppx:configurations/ppx:configuration[@name=$configname]/ppx:resource[@name=$name]")
def getconfigurationResource(self, config_name, name):
- configuration = self.getconfiguration(config_name)
- if configuration:
- for resource in configuration.getresource():
- if resource.getname() == name:
- return resource
+ resources = resources_xpath(self, configname=config_name, name=name)
+ if len(resources) == 1:
+ return resources[0]
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)
configuration = self.getconfiguration(config_name)
- if configuration:
- for resource in configuration.getresource():
- if resource.getname() == name:
- raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name)
- new_resource = PLCOpenClasses["configuration_resource"]()
+ if configuration is not None:
+ new_resource = PLCOpenParser.CreateElement("resource", "configuration")
new_resource.setname(name)
configuration.appendresource(new_resource)
setattr(cls, "addconfigurationResource", addconfigurationResource)
def removeconfigurationResource(self, config_name, name):
configuration = self.getconfiguration(config_name)
- if configuration:
- found = False
- for idx, resource in enumerate(configuration.getresource()):
- if resource.getname() == name:
- configuration.removeresource(idx)
- found = True
- break
- if not found:
- raise ValueError, _("\"%s\" resource doesn't exist in \"%s\" configuration !!!")%(name, config_name)
+ found = False
+ if configuration is not None:
+ 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)
setattr(cls, "removeconfigurationResource", removeconfigurationResource)
def updateElementName(self, old_name, new_name):
- for datatype in self.types.getdataTypeElements():
+ for datatype in self.getdataTypes():
datatype.updateElementName(old_name, new_name)
- for pou in self.types.getpouElements():
+ for pou in self.getpous():
pou.updateElementName(old_name, new_name)
- for configuration in self.instances.configurations.getconfiguration():
+ for configuration in self.getconfigurations():
configuration.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, old_leading, new_leading):
address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)
- for pou in self.types.getpouElements():
+ for pou in self.getpous():
pou.updateElementAddress(address_model, new_leading)
- for configuration in self.instances.configurations.getconfiguration():
+ for configuration in self.getconfigurations():
configuration.updateElementAddress(address_model, new_leading)
setattr(cls, "updateElementAddress", updateElementAddress)
def removeVariableByAddress(self, address):
- for pou in self.types.getpouElements():
+ for pou in self.getpous():
pou.removeVariableByAddress(address)
- for configuration in self.instances.configurations.getconfiguration():
+ for configuration in self.getconfigurations():
configuration.removeVariableByAddress(address)
setattr(cls, "removeVariableByAddress", removeVariableByAddress)
def removeVariableByFilter(self, leading):
address_model = re.compile(FILTER_ADDRESS_MODEL % leading)
- for pou in self.types.getpouElements():
+ for pou in self.getpous():
pou.removeVariableByFilter(address_model)
- for configuration in self.instances.configurations.getconfiguration():
+ for configuration in self.getconfigurations():
configuration.removeVariableByFilter(address_model)
setattr(cls, "removeVariableByFilter", removeVariableByFilter)
- def RefreshDataTypeHierarchy(self):
- self.EnumeratedDataTypeValues = {}
- self.CustomDataTypeRange = {}
- self.CustomTypeHierarchy = {}
- for datatype in self.getdataTypes():
- self.AddCustomDataType(datatype)
- setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)
-
- def AddCustomDataType(self, datatype):
- name = datatype.getname()
- basetype_content = datatype.getbaseType().getcontent()
- if basetype_content["value"] is None:
- self.CustomTypeHierarchy[name] = basetype_content["name"]
- elif basetype_content["name"] in ["string", "wstring"]:
- self.CustomTypeHierarchy[name] = basetype_content["name"].upper()
- elif basetype_content["name"] == "derived":
- self.CustomTypeHierarchy[name] = basetype_content["value"].getname()
- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
- range = (basetype_content["value"].range.getlower(),
- basetype_content["value"].range.getupper())
- self.CustomDataTypeRange[name] = range
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["value"] is None:
- self.CustomTypeHierarchy[name] = base_type["name"]
- else:
- self.CustomTypeHierarchy[name] = base_type["value"].getname()
- else:
- if basetype_content["name"] == "enum":
- values = []
- for value in basetype_content["value"].values.getvalue():
- values.append(value.getname())
- self.EnumeratedDataTypeValues[name] = values
- self.CustomTypeHierarchy[name] = "ANY_DERIVED"
- setattr(cls, "AddCustomDataType", AddCustomDataType)
-
- # Update Block types with user-defined pou added
- def RefreshCustomBlockTypes(self):
- # Reset the tree of user-defined pou cross-use
- self.CustomBlockTypes = OrderedDict()
- for pou in self.getpous():
- self.AddCustomBlockType(pou)
- setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)
-
- def AddCustomBlockType(self, pou):
- 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():
- return_type = pou.interface.getreturnType()
- if return_type:
- var_type = return_type.getcontent()
- if var_type["name"] == "derived":
- block_infos["outputs"].append(("OUT", var_type["value"].getname(), "none"))
- elif var_type["name"] in ["string", "wstring"]:
- block_infos["outputs"].append(("OUT", var_type["name"].upper(), "none"))
- else:
- block_infos["outputs"].append(("OUT", var_type["name"], "none"))
- for type, varlist in pou.getvars():
- if type == "InOut":
- for var in varlist.getvariable():
- var_type = var.type.getcontent()
- if var_type["name"] == "derived":
- block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))
- block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))
- elif var_type["name"] in ["string", "wstring"]:
- block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))
- block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))
- else:
- block_infos["inputs"].append((var.getname(), var_type["name"], "none"))
- block_infos["outputs"].append((var.getname(), var_type["name"], "none"))
- elif type == "Input":
- for var in varlist.getvariable():
- var_type = var.type.getcontent()
- if var_type["name"] == "derived":
- block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))
- elif var_type["name"] in ["string", "wstring"]:
- block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))
- else:
- block_infos["inputs"].append((var.getname(), var_type["name"], "none"))
- elif type == "Output":
- for var in varlist.getvariable():
- var_type = var.type.getcontent()
- if var_type["name"] == "derived":
- block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))
- elif var_type["name"] in ["string", "wstring"]:
- block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))
- else:
- block_infos["outputs"].append((var.getname(), var_type["name"], "none"))
- 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[pou_name]=block_infos
- setattr(cls, "AddCustomBlockType", AddCustomBlockType)
-
- def AddElementUsingTreeInstance(self, name, type_infos):
- typename = type_infos.getname()
- elements = self.ElementUsingTree.setdefault(typename, set())
- elements.add(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()
- # Analyze each datatype
- for datatype in datatypes:
- name = datatype.getname()
- basetype_content = datatype.baseType.getcontent()
- if basetype_content["name"] == "derived":
- self.AddElementUsingTreeInstance(name,
- basetype_content["value"])
- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]:
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["name"] == "derived":
- self.AddElementUsingTreeInstance(name, base_type["value"])
- elif basetype_content["name"] == "struct":
- for element in basetype_content["value"].getvariable():
- type_content = element.type.getcontent()
- if type_content["name"] == "derived":
- self.AddElementUsingTreeInstance(name, type_content["value"])
- # 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":
- self.AddElementUsingTreeInstance(name, vartype_content["value"])
-
- setattr(cls, "RefreshElementUsingTree", RefreshElementUsingTree)
-
- def GetParentType(self, type):
- if self.CustomTypeHierarchy.has_key(type):
- return self.CustomTypeHierarchy[type]
- elif TypeHierarchy.has_key(type):
- return TypeHierarchy[type]
- return None
- setattr(cls, "GetParentType", GetParentType)
-
- def GetBaseType(self, type):
- parent_type = self.GetParentType(type)
- if parent_type is not None:
- if parent_type.startswith("ANY"):
- return type
- else:
- return self.GetBaseType(parent_type)
- return None
- setattr(cls, "GetBaseType", GetBaseType)
-
- def GetSubrangeBaseTypes(self, exclude):
- derived = []
- for type in self.CustomTypeHierarchy.keys():
- for base_type in DataTypeRange.keys():
- if self.IsOfType(type, base_type) and not self.IsOfType(type, exclude):
- derived.append(type)
- break
- return derived
- setattr(cls, "GetSubrangeBaseTypes", GetSubrangeBaseTypes)
-
- """
- returns true if the given data type is the same that "reference" meta-type or one of its types.
- """
- def IsOfType(self, type, reference):
- if reference is None:
- return True
- elif type == reference:
- return True
- else:
- parent_type = self.GetParentType(type)
- if parent_type is not None:
- return self.IsOfType(parent_type, reference)
- return False
- setattr(cls, "IsOfType", IsOfType)
-
- # Return if pou given by name is used by another pou
- def ElementIsUsed(self, name):
- elements = self.ElementUsingTree.get(name, None)
- return elements is not None
- setattr(cls, "ElementIsUsed", ElementIsUsed)
-
- def DataTypeIsDerived(self, name):
- return name in self.CustomTypeHierarchy.values()
- setattr(cls, "DataTypeIsDerived", DataTypeIsDerived)
-
- # Return if pou given by name is directly or undirectly used by the reference pou
- def ElementIsUsedBy(self, name, reference):
- elements = self.ElementUsingTree.get(name, set())
- # Test if pou is directly used by reference
- if reference in elements:
- return True
- else:
- # Test if pou is undirectly used by reference, by testing if pous
- # that directly use pou is directly or undirectly used by reference
- selffn = self.ElementIsUsedBy
- for element in elements:
- if selffn(element, reference):
- return True
- return False
- setattr(cls, "ElementIsUsedBy", ElementIsUsedBy)
-
- def GetDataTypeRange(self, type):
- if self.CustomDataTypeRange.has_key(type):
- return self.CustomDataTypeRange[type]
- elif DataTypeRange.has_key(type):
- return DataTypeRange[type]
- else:
- parent_type = self.GetParentType(type)
- if parent_type is not None:
- return self.GetDataTypeRange(parent_type)
- return None
- setattr(cls, "GetDataTypeRange", GetDataTypeRange)
-
- def GetEnumeratedDataTypeValues(self, type = None):
- if type is None:
- all_values = []
- for values in self.EnumeratedDataTypeValues.values():
- all_values.extend(values)
- return all_values
- elif self.EnumeratedDataTypeValues.has_key(type):
- return self.EnumeratedDataTypeValues[type]
- return []
+ enumerated_values_xpath = PLCOpen_XPath(
+ "ppx:types/ppx:dataTypes/ppx:dataType/ppx:baseType/ppx:enum/ppx:values/ppx:value")
+ def GetEnumeratedDataTypeValues(self):
+ return [value.getname() for value in enumerated_values_xpath(self)]
setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues)
- # Function that returns the block definition associated to the block type given
- def GetCustomBlockType(self, typename, inputs = None):
- customblocktype = self.CustomBlockTypes.get(typename,None)
- if customblocktype is not None:
- if inputs is not None and inputs != "undefined":
- customblock_inputs = tuple([var_type for name, var_type, modifier in customblocktype["inputs"]])
- if inputs == customblock_inputs:
- return customblocktype
- else:
- return customblocktype
- return None
- setattr(cls, "GetCustomBlockType", GetCustomBlockType)
-
- # Return Block types checking for recursion
- def GetCustomBlockTypes(self, exclude = None, onlyfunctions = False):
- if exclude is not None:
- return [customblocktype for name,customblocktype in self.CustomBlockTypes.iteritems()
- if (customblocktype["type"] != "program"
- and name != exclude
- and not self.ElementIsUsedBy(exclude, name)
- and not (onlyfunctions and customblocktype["type"] != "function"))]
- return [customblocktype for customblocktype in self.CustomBlockTypes.itervalues()
- if (customblocktype["type"] != "program"
- and not (onlyfunctions and customblocktype["type"] != "function"))]
- setattr(cls, "GetCustomBlockTypes", GetCustomBlockTypes)
-
- # Return Function Block types checking for recursion
- def GetCustomFunctionBlockTypes(self, exclude = None):
- if exclude is not None:
- return [customblocktype for name,customblocktype in self.CustomBlockTypes.iteritems()
- if (customblocktype["type"] == "functionBlock"
- and name != exclude
- and not self.ElementIsUsedBy(exclude, name))]
- return [customblocktype for customblocktype in self.CustomBlockTypes.itervalues()
- if customblocktype["type"] == "functionBlock"]
- setattr(cls, "GetCustomFunctionBlockTypes", GetCustomFunctionBlockTypes)
-
- # Return Block types checking for recursion
- def GetCustomBlockResource(self):
- return [customblocktype for customblocktype in self.CustomBlockTypes.itervalues()
- if customblocktype["type"] == "program"]
- setattr(cls, "GetCustomBlockResource", GetCustomBlockResource)
-
- # Return Data Types checking for recursion
- def GetCustomDataTypes(self, exclude = "", only_locatable = False):
- customdatatypes = []
- for customdatatype in self.getdataTypes():
- if not only_locatable or self.IsLocatableType(customdatatype):
- customdatatype_name = customdatatype.getname()
- if customdatatype_name != exclude and not self.ElementIsUsedBy(exclude, customdatatype_name):
- customdatatypes.append({"name": customdatatype_name, "infos": customdatatype})
- return customdatatypes
- setattr(cls, "GetCustomDataTypes", GetCustomDataTypes)
-
- # Return if Data Type can be used for located variables
- def IsLocatableType(self, datatype):
- basetype_content = datatype.baseType.getcontent()
- if basetype_content["name"] in ["enum", "struct"]:
- return False
- elif basetype_content["name"] == "derived":
- base_type = self.getdataType(basetype_content["value"].getname())
- if base_type is not None:
- return self.IsLocatableType(base_type)
- elif basetype_content["name"] == "array":
- array_base_type = basetype_content["value"].baseType.getcontent()
- if array_base_type["value"] is not None and array_base_type["name"] not in ["string", "wstring"]:
- base_type = self.getdataType(array_base_type["value"].getname())
- if base_type is not None:
- return self.IsLocatableType(base_type)
- return True
- setattr(cls, "IsLocatableType", IsLocatableType)
-
def Search(self, criteria, parent_infos=[]):
result = self.types.Search(criteria, parent_infos)
for configuration in self.instances.configurations.getconfiguration():
@@ -711,13 +471,8 @@
return result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("project_fileHeader", None)
-if cls:
- cls.singleLineAttributes = False
-
-cls = PLCOpenClasses.get("project_contentHeader", None)
-if cls:
- cls.singleLineAttributes = False
+cls = PLCOpenParser.GetElementClass("contentHeader", "project")
+if cls:
def setpageSize(self, width, height):
self.coordinateInfo.setpageSize(width, height)
@@ -740,7 +495,7 @@
return scaling
setattr(cls, "getscaling", getscaling)
-cls = PLCOpenClasses.get("contentHeader_coordinateInfo", None)
+cls = PLCOpenParser.GetElementClass("coordinateInfo", "contentHeader")
if cls:
def setpageSize(self, width, height):
if width == 0 and height == 0:
@@ -809,7 +564,7 @@
variables = varlist.getvariable()
for i in xrange(len(variables)-1, -1, -1):
if variables[i].getaddress() == address:
- variables.pop(i)
+ variables.remove(variables[i])
def _removeConfigurationResourceVariableByFilter(self, address_model):
for varlist in self.getglobalVars():
@@ -819,7 +574,7 @@
if var_address is not None:
result = address_model.match(var_address)
if result is not None:
- variables.pop(i)
+ variables.remove(variables[i])
def _SearchInConfigurationResource(self, criteria, parent_infos=[]):
search_result = _Search([("name", self.getname())], criteria, parent_infos)
@@ -839,33 +594,21 @@
var_number += 1
return search_result
-cls = PLCOpenClasses.get("configurations_configuration", None)
-if cls:
-
- def addglobalVar(self, type, name, location="", description=""):
+cls = PLCOpenParser.GetElementClass("configuration", "configurations")
+if cls:
+
+ def addglobalVar(self, var_type, name, location="", description=""):
globalvars = self.getglobalVars()
if len(globalvars) == 0:
- globalvars.append(PLCOpenClasses["varList"]())
- var = PLCOpenClasses["varListPlain_variable"]()
+ globalvars.append(PLCOpenParser.CreateElement("varList"))
+ var = PLCOpenParser.CreateElement("variable", "varListPlain")
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)
+ ft = PLCOpenParser.CreateElement("documentation", "variable")
+ ft.setanyText(description)
var.setdocumentation(ft)
globalvars[-1].appendvariable(var)
setattr(cls, "addglobalVar", addglobalVar)
@@ -896,7 +639,7 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("configuration_resource", None)
+cls = PLCOpenParser.GetElementClass("resource", "configuration")
if cls:
def updateElementName(self, old_name, new_name):
_updateConfigurationResourceElementName(self, old_name, new_name)
@@ -937,7 +680,7 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("resource_task", None)
+cls = PLCOpenParser.GetElementClass("task", "resource")
if cls:
def compatibility(self, tree):
if tree.hasAttribute("interval"):
@@ -986,7 +729,7 @@
criteria, parent_infos)
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("pouInstance", None)
+cls = PLCOpenParser.GetElementClass("pouInstance")
if cls:
def compatibility(self, tree):
if tree.hasAttribute("type"):
@@ -1004,31 +747,33 @@
criteria, parent_infos)
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("varListPlain_variable", None)
+cls = PLCOpenParser.GetElementClass("variable", "varListPlain")
if 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":
- return vartype_content["value"].getname()
+ if vartype_content_name == "derived":
+ return vartype_content.getname()
# Variable type is a string type
- elif vartype_content["name"] in ["string", "wstring"]:
- return vartype_content["name"].upper()
+ elif vartype_content_name in ["string", "wstring"]:
+ return vartype_content_name.upper()
# Variable type is an array
- elif vartype_content["name"] == "array":
- base_type = vartype_content["value"].baseType.getcontent()
+ elif vartype_content_name == "array":
+ base_type = vartype_content.baseType.getcontent()
+ base_type_name = base_type.getLocalTag()
# Array derived directly from a user defined type
- if base_type["name"] == "derived":
- basetype_name = base_type["value"].getname()
+ if base_type_name == "derived":
+ basetype_name = base_type.getname()
# Array derived directly from a string type
- elif base_type["name"] in ["string", "wstring"]:
- basetype_name = base_type["name"].upper()
+ elif base_type_name in ["string", "wstring"]:
+ basetype_name = base_type_name.upper()
# Array derived directly from an elementary type
else:
- basetype_name = base_type["name"]
- return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content["value"].getdimension())), basetype_name)
+ basetype_name = base_type_name
+ return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content.getdimension())), basetype_name)
# Variable type is an elementary type
- return vartype_content["name"]
+ return vartype_content_name
setattr(cls, "gettypeAsText", gettypeAsText)
def Search(self, criteria, parent_infos=[]):
@@ -1045,7 +790,7 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("project_types", None)
+cls = PLCOpenParser.GetElementClass("types", "project")
if cls:
def getdataTypeElements(self):
return self.dataTypes.getdataType()
@@ -1060,10 +805,10 @@
setattr(cls, "getdataTypeElement", getdataTypeElement)
def appenddataTypeElement(self, name):
- new_datatype = PLCOpenClasses["dataTypes_dataType"]()
+ new_datatype = PLCOpenParser.CreateElement("dataType", "dataTypes")
+ self.dataTypes.appenddataType(new_datatype)
new_datatype.setname(name)
- new_datatype.baseType.setcontent({"name" : "BOOL", "value" : None})
- self.dataTypes.appenddataType(new_datatype)
+ new_datatype.baseType.setcontent(PLCOpenParser.CreateElement("BOOL", "dataType"))
setattr(cls, "appenddataTypeElement", appenddataTypeElement)
def insertdataTypeElement(self, index, dataType):
@@ -1072,9 +817,9 @@
def removedataTypeElement(self, name):
found = False
- for idx, element in enumerate(self.dataTypes.getdataType()):
+ for element in self.dataTypes.getdataType():
if element.getname() == name:
- self.dataTypes.removedataType(idx)
+ self.dataTypes.remove(element)
found = True
break
if not found:
@@ -1097,12 +842,12 @@
for element in self.pous.getpou():
if element.getname() == name:
raise ValueError, _("\"%s\" POU already exists !!!")%name
- new_pou = PLCOpenClasses["pous_pou"]()
+ new_pou = PLCOpenParser.CreateElement("pou", "pous")
+ self.pous.appendpou(new_pou)
new_pou.setname(name)
new_pou.setpouType(pou_type)
- new_pou.appendbody(PLCOpenClasses["body"]())
+ new_pou.appendbody(PLCOpenParser.CreateElement("body", "pou"))
new_pou.setbodyType(body_type)
- self.pous.appendpou(new_pou)
setattr(cls, "appendpouElement", appendpouElement)
def insertpouElement(self, index, pou):
@@ -1111,9 +856,9 @@
def removepouElement(self, name):
found = False
- for idx, element in enumerate(self.pous.getpou()):
+ for element in self.pous.getpou():
if element.getname() == name:
- self.pous.removepou(idx)
+ self.pous.remove(element)
found = True
break
if not found:
@@ -1133,7 +878,7 @@
def _updateBaseTypeElementName(self, old_name, new_name):
self.baseType.updateElementName(old_name, new_name)
-cls = PLCOpenClasses.get("dataTypes_dataType", None)
+cls = PLCOpenParser.GetElementClass("dataType", "dataTypes")
if cls:
setattr(cls, "updateElementName", _updateBaseTypeElementName)
@@ -1149,33 +894,45 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("dataType", None)
+cls = PLCOpenParser.GetElementClass("dataType")
if cls:
def updateElementName(self, old_name, new_name):
- if self.content["name"] in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]:
- self.content["value"].updateElementName(old_name, new_name)
- elif self.content["name"] == "struct":
- for element in self.content["value"].getvariable():
+ content_name = self.content.getLocalTag()
+ if content_name in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]:
+ self.content.updateElementName(old_name, new_name)
+ elif content_name == "struct":
+ for element in self.content.getvariable():
element_type = element.type.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def Search(self, criteria, parent_infos=[]):
search_result = []
- if self.content["name"] in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]:
- search_result.extend(self.content["value"].Search(criteria, parent_infos))
- elif self.content["name"] == "struct":
- for i, element in enumerate(self.content["value"].getvariable()):
+ content_name = self.content.getLocalTag()
+ if content_name in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]:
+ search_result.extend(self.content.Search(criteria, parent_infos + ["base"]))
+ elif content_name == "struct":
+ for i, element in enumerate(self.content.getvariable()):
search_result.extend(element.Search(criteria, parent_infos + ["struct", i]))
else:
- basetype = self.content["name"]
- if basetype in ["string", "wstring"]:
- basetype = basetype.upper()
- search_result.extend(_Search([("base", basetype)], criteria, parent_infos))
+ if content_name in ["string", "wstring"]:
+ content_name = content_name.upper()
+ search_result.extend(_Search([("base", content_name)], criteria, parent_infos))
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("derivedTypes_array", None)
+cls = PLCOpenParser.GetElementClass("derived", "dataType")
+if cls:
+ def updateElementName(self, old_name, new_name):
+ if 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:
setattr(cls, "updateElementName", _updateBaseTypeElementName)
@@ -1195,68 +952,100 @@
criteria, parent_infos))
return search_result
-cls = PLCOpenClasses.get("derivedTypes_subrangeSigned", None)
+cls = PLCOpenParser.GetElementClass("subrangeSigned", "dataType")
if cls:
setattr(cls, "updateElementName", _updateBaseTypeElementName)
setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenClasses.get("derivedTypes_subrangeUnsigned", None)
+cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "dataType")
if cls:
setattr(cls, "updateElementName", _updateBaseTypeElementName)
setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenClasses.get("derivedTypes_enum", None)
+cls = PLCOpenParser.GetElementClass("enum", "dataType")
if cls:
def updateElementName(self, old_name, new_name):
pass
setattr(cls, "updateElementName", updateElementName)
+ enumerated_datatype_values_xpath = PLCOpen_XPath("ppx:values/ppx:value")
def Search(self, criteria, parent_infos=[]):
search_result = []
- for i, value in enumerate(self.values.getvalue()):
+ for i, value in enumerate(enumerated_datatype_values_xpath(self)):
for result in TestTextElement(value.getname(), criteria):
search_result.append((tuple(parent_infos + ["value", i]),) + result)
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("pous_pou", None)
-if 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")
+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,
+ "inputs" : [],
+ "outputs" : [],
+ "comment" : self.getdescription()}
+ if self.interface is not None:
+ return_type = self.interface.getreturnType()
+ if return_type is not None:
+ block_infos["outputs"].append(
+ ("OUT", _getvariableTypeinfos(return_type), "none"))
+ block_infos["inputs"].extend(
+ [(var.getname(), _getvariableTypeinfos(var.type), "none")
+ for var in block_inputs_xpath(self)])
+ block_infos["outputs"].extend(
+ [(var.getname(), _getvariableTypeinfos(var.type), "none")
+ for var in block_outputs_xpath(self)])
+
+ 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"]])))
+ return block_infos
+ setattr(cls, "getblockInfos", getblockInfos)
def setdescription(self, description):
doc = self.getdocumentation()
if doc is None:
- doc = PLCOpenClasses["formattedText"]()
+ doc = PLCOpenParser.CreateElement("documentation", "pou")
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, type):
+ def setbodyType(self, body_type):
if len(self.body) > 0:
- if type == "IL":
- self.body[0].setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
- elif type == "ST":
- self.body[0].setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
- elif type == "LD":
- self.body[0].setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
- elif type == "FBD":
- self.body[0].setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
- elif type == "SFC":
- self.body[0].setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
+ if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:
+ self.body[0].setcontent(PLCOpenParser.CreateElement(body_type, "body"))
else:
raise ValueError, "%s isn't a valid body type!"%type
setattr(cls, "setbodyType", setbodyType)
def getbodyType(self):
if len(self.body) > 0:
- return self.body[0].getcontent()["name"]
+ return self.body[0].getcontent().getLocalTag()
setattr(cls, "getbodyType", getbodyType)
def resetexecutionOrder(self):
@@ -1274,9 +1063,9 @@
self.body[0].setelementExecutionOrder(instance, new_executionOrder)
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
- def addinstance(self, name, instance):
+ def addinstance(self, instance):
if len(self.body) > 0:
- self.body[0].appendcontentInstance(name, instance)
+ self.body[0].appendcontentInstance(instance)
setattr(cls, "addinstance", addinstance)
def getinstances(self):
@@ -1326,88 +1115,78 @@
for name, value in VarTypes.items():
reverse_types[value] = name
for varlist in self.interface.getcontent():
- vars.append((reverse_types[varlist["name"]], varlist["value"]))
+ vars.append((reverse_types[varlist.getLocalTag()], varlist))
return vars
setattr(cls, "getvars", getvars)
def setvars(self, vars):
if self.interface is None:
- self.interface = PLCOpenClasses["pou_interface"]()
- self.interface.setcontent([])
- for vartype, varlist in vars:
- self.interface.appendcontent({"name" : VarTypes[vartype], "value" : varlist})
+ self.interface = PLCOpenParser.CreateElement("interface", "pou")
+ self.interface.setcontent(vars)
setattr(cls, "setvars", setvars)
- def addpouLocalVar(self, type, name, location="", description=""):
- self.addpouVar(type, name, location=location, description=description)
+ def addpouLocalVar(self, var_type, name, location="", description=""):
+ self.addpouVar(var_type, name, location=location, description=description)
setattr(cls, "addpouLocalVar", addpouLocalVar)
- def addpouExternalVar(self, type, name):
+ def addpouExternalVar(self, var_type, name):
self.addpouVar(type, name, "externalVars")
setattr(cls, "addpouExternalVar", addpouExternalVar)
- def addpouVar(self, type, name, var_class="localVars", location="", description=""):
+ def addpouVar(self, var_type, name, var_class="localVars", location="", description=""):
if self.interface is None:
- self.interface = PLCOpenClasses["pou_interface"]()
+ self.interface = PLCOpenParser.CreateElement("interface", "pou")
content = self.interface.getcontent()
- if len(content) == 0 or content[-1]["name"] != var_class:
- content.append({"name" : var_class, "value" : PLCOpenClasses["interface_%s" % var_class]()})
+ if len(content) == 0:
+ varlist = PLCOpenParser.CreateElement(var_class, "interface")
+ self.interface.setcontent([varlist])
+ elif content[-1] != var_class:
+ varlist = PLCOpenParser.CreateElement(var_class, "interface")
+ content[-1].addnext(varlist)
else:
- varlist = content[-1]["value"]
+ varlist = content[-1]
variables = varlist.getvariable()
if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress():
- content.append({"name" : var_class, "value" : PLCOpenClasses["interface_%s" % var_class]()})
- var = PLCOpenClasses["varListPlain_variable"]()
+ varlist = PLCOpenParser.CreateElement(var_class, "interface")
+ content[-1].addnext(varlist)
+ var = PLCOpenParser.CreateElement("variable", "varListPlain")
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)
+ ft = PLCOpenParser.CreateElement("documentation", "variable")
+ ft.setanyText(description)
var.setdocumentation(ft)
- content[-1]["value"].appendvariable(var)
+ varlist.appendvariable(var)
setattr(cls, "addpouVar", addpouVar)
def changepouVar(self, old_type, old_name, new_type, new_name):
if self.interface is not None:
content = self.interface.getcontent()
for varlist in content:
- variables = varlist["value"].getvariable()
+ variables = varlist.getvariable()
for var in variables:
if var.getname() == old_name:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived" and vartype_content["value"].getname() == old_type:
+ if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == old_type:
var.setname(new_name)
- vartype_content["value"].setname(new_type)
+ vartype_content.setname(new_type)
return
setattr(cls, "changepouVar", changepouVar)
- def removepouVar(self, type, name):
+ def removepouVar(self, var_type, name):
if self.interface is not None:
content = self.interface.getcontent()
for varlist in content:
- variables = varlist["value"].getvariable()
- for var in variables:
+ for var in varlist.getvariable():
if var.getname() == name:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived" and vartype_content["value"].getname() == type:
- variables.remove(var)
+ if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == var_type:
+ varlist.remove(var)
break
- if len(varlist["value"].getvariable()) == 0:
+ if len(varlist.getvariable()) == 0:
content.remove(varlist)
break
setattr(cls, "removepouVar", removepouVar)
@@ -1415,7 +1194,7 @@
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
+ if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and
(name and instance.getinstanceName() == name or
block_type and instance.gettypeName() == block_type)):
return True
@@ -1434,22 +1213,22 @@
return False
setattr(cls, "hasblock", hasblock)
- def addtransition(self, name, type):
- if not self.transitions:
+ def addtransition(self, name, body_type):
+ if self.transitions is None:
self.addtransitions()
self.transitions.settransition([])
- transition = PLCOpenClasses["transitions_transition"]()
+ transition = PLCOpenParser.CreateElement("transition", "transitions")
+ self.transitions.appendtransition(transition)
transition.setname(name)
- transition.setbodyType(type)
- if type == "ST":
- transition.settext(":= ;")
- elif type == "IL":
- transition.settext("\tST\t%s"%name)
- self.transitions.appendtransition(transition)
+ transition.setbodyType(body_type)
+ if body_type == "ST":
+ transition.setanyText(":= ;")
+ elif body_type == "IL":
+ transition.setanyText("\tST\t%s"%name)
setattr(cls, "addtransition", addtransition)
def gettransition(self, name):
- if self.transitions:
+ if self.transitions is not None:
for transition in self.transitions.gettransition():
if transition.getname() == name:
return transition
@@ -1457,42 +1236,40 @@
setattr(cls, "gettransition", gettransition)
def gettransitionList(self):
- if self.transitions:
+ if self.transitions is not None:
return self.transitions.gettransition()
return []
setattr(cls, "gettransitionList", gettransitionList)
def removetransition(self, name):
- if self.transitions:
- transitions = self.transitions.gettransition()
- i = 0
+ if self.transitions is not None:
removed = False
- while i < len(transitions) and not removed:
- if transitions[i].getname() == name:
- if transitions[i].getbodyType() in ["FBD", "LD", "SFC"]:
- for instance in transitions[i].getinstances():
- if isinstance(instance, PLCOpenClasses["fbdObjects_block"]):
+ for transition in self.transitions.gettransition():
+ if 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())
- transitions.pop(i)
+ self.transitions.remove(transition)
removed = True
- i += 1
+ break
if not removed:
raise ValueError, _("Transition with name %s doesn't exist!")%name
setattr(cls, "removetransition", removetransition)
- def addaction(self, name, type):
- if not self.actions:
+ def addaction(self, name, body_type):
+ if self.actions is None:
self.addactions()
self.actions.setaction([])
- action = PLCOpenClasses["actions_action"]()
+ action = PLCOpenParser.CreateElement("action", "actions")
+ self.actions.appendaction(action)
action.setname(name)
- action.setbodyType(type)
- self.actions.appendaction(action)
+ action.setbodyType(body_type)
setattr(cls, "addaction", addaction)
def getaction(self, name):
- if self.actions:
+ if self.actions is not None:
for action in self.actions.getaction():
if action.getname() == name:
return action
@@ -1506,28 +1283,26 @@
setattr(cls, "getactionList", getactionList)
def removeaction(self, name):
- if self.actions:
- actions = self.actions.getaction()
- i = 0
+ if self.actions is not None:
removed = False
- while i < len(actions) and not removed:
- if actions[i].getname() == name:
- if actions[i].getbodyType() in ["FBD", "LD", "SFC"]:
- for instance in actions[i].getinstances():
- if isinstance(instance, PLCOpenClasses["fbdObjects_block"]):
+ for action in self.actions.getaction():
+ if 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())
- actions.pop(i)
+ self.actions.remove(action)
removed = True
- i += 1
+ break
if not removed:
raise ValueError, _("Action with name %s doesn't exist!")%name
setattr(cls, "removeaction", removeaction)
def updateElementName(self, old_name, new_name):
- if self.interface:
+ if self.interface is not None:
for content in self.interface.getcontent():
- for var in content["value"].getvariable():
+ for var in content.getvariable():
var_address = var.getaddress()
if var_address is not None:
if var_address == old_name:
@@ -1535,9 +1310,9 @@
if var.getname() == old_name:
var.setname(new_name)
var_type_content = var.gettype().getcontent()
- if var_type_content["name"] == "derived":
- if var_type_content["value"].getname() == old_name:
- var_type_content["value"].setname(new_name)
+ if var_type_content.getLocalTag() == "derived":
+ if 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)
@@ -1546,9 +1321,9 @@
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.interface:
+ if self.interface is not None:
for content in self.interface.getcontent():
- for var in content["value"].getvariable():
+ for var in content.getvariable():
var_address = var.getaddress()
if var_address is not None:
var.setaddress(update_address(var_address, address_model, new_leading))
@@ -1560,24 +1335,22 @@
setattr(cls, "updateElementAddress", updateElementAddress)
def removeVariableByAddress(self, address):
- if self.interface:
+ if self.interface is not None:
for content in self.interface.getcontent():
- variables = content["value"].getvariable()
- for i in xrange(len(variables)-1, -1, -1):
- if variables[i].getaddress() == address:
- variables.pop(i)
+ for variable in content.getvariable():
+ if variable.getaddress() == address:
+ content.remove(variable)
setattr(cls, "removeVariableByAddress", removeVariableByAddress)
def removeVariableByFilter(self, address_model):
- if self.interface:
+ if self.interface is not None:
for content in self.interface.getcontent():
- variables = content["value"].getvariable()
- for i in xrange(len(variables)-1, -1, -1):
- var_address = variables[i].getaddress()
+ for variable in content.getvariable():
+ var_address = variable.getaddress()
if var_address is not None:
result = address_model.match(var_address)
if result is not None:
- variables.pop(i)
+ content.remove(variable)
setattr(cls, "removeVariableByFilter", removeVariableByFilter)
def Search(self, criteria, parent_infos=[]):
@@ -1589,11 +1362,11 @@
if self.interface is not None:
var_number = 0
for content in self.interface.getcontent():
- variable_type = searchResultVarTypes.get(content["value"], "var_local")
- variables = content["value"].getvariable()
- for modifier, has_modifier in [("constant", content["value"].getconstant()),
- ("retain", content["value"].getretain()),
- ("non_retain", content["value"].getnonretain())]:
+ variable_type = searchResultVarTypes.get(content, "var_local")
+ variables = content.getvariable()
+ for modifier, has_modifier in [("constant", content.getconstant()),
+ ("retain", content.getretain()),
+ ("non_retain", content.getnonretain())]:
if has_modifier:
for result in TestTextElement(modifier, criteria):
search_result.append((tuple(parent_infos + [variable_type, (var_number, var_number + len(variables)), modifier]),) + result)
@@ -1610,22 +1383,14 @@
return search_result
setattr(cls, "Search", Search)
-def setbodyType(self, type):
- if type == "IL":
- self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
- elif type == "ST":
- self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
- elif type == "LD":
- self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
- elif type == "FBD":
- self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
- elif type == "SFC":
- self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
+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 getbodyType(self):
- return self.body.getcontent()["name"]
+ return self.body.getcontent().getLocalTag()
def resetexecutionOrder(self):
self.body.resetexecutionOrder()
@@ -1636,8 +1401,8 @@
def setelementExecutionOrder(self, instance, new_executionOrder):
self.body.setelementExecutionOrder(instance, new_executionOrder)
-def addinstance(self, name, instance):
- self.body.appendcontentInstance(name, instance)
+def addinstance(self, instance):
+ self.body.appendcontentInstance(instance)
def getinstances(self):
return self.body.getcontentInstances()
@@ -1663,7 +1428,7 @@
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
+ if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and
(name and instance.getinstanceName() == name or
block_type and instance.gettypeName() == block_type)):
return True
@@ -1678,7 +1443,7 @@
self.body.updateElementAddress(address_model, new_leading)
-cls = PLCOpenClasses.get("transitions_transition", None)
+cls = PLCOpenParser.GetElementClass("transition", "transitions")
if cls:
setattr(cls, "setbodyType", setbodyType)
setattr(cls, "getbodyType", getbodyType)
@@ -1706,7 +1471,7 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("actions_action", None)
+cls = PLCOpenParser.GetElementClass("action", "actions")
if cls:
setattr(cls, "setbodyType", setbodyType)
setattr(cls, "getbodyType", getbodyType)
@@ -1734,27 +1499,9 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("body", None)
+cls = PLCOpenParser.GetElementClass("body")
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)
@@ -1766,44 +1513,44 @@
setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId)
def resetexecutionOrder(self):
- if self.content["name"] == "FBD":
- for element in self.content["value"].getcontent():
- if not isinstance(element["value"], (PLCOpenClasses.get("commonObjects_comment", None),
- PLCOpenClasses.get("commonObjects_connector", None),
- PLCOpenClasses.get("commonObjects_continuation", None))):
- element["value"].setexecutionOrderId(0)
+ if self.content.getLocalTag() == "FBD":
+ 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)
else:
raise TypeError, _("Can only generate execution order on FBD networks!")
setattr(cls, "resetexecutionOrder", resetexecutionOrder)
def compileexecutionOrder(self):
- if self.content["name"] == "FBD":
+ if self.content.getLocalTag() == "FBD":
self.resetexecutionOrder()
self.resetcurrentExecutionOrderId()
- for element in self.content["value"].getcontent():
- if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_outVariable", None)) and element["value"].getexecutionOrderId() == 0:
- connections = element["value"].connectionPointIn.getconnections()
+ for element in self.content.getcontent():
+ if isinstance(element, PLCOpenParser.GetElementClass("outVariable", "fbdObjects")) and element.getexecutionOrderId() == 0:
+ connections = element.connectionPointIn.getconnections()
if connections and len(connections) == 1:
self.compileelementExecutionOrder(connections[0])
- element["value"].setexecutionOrderId(self.getnewExecutionOrderId())
+ element.setexecutionOrderId(self.getnewExecutionOrderId())
else:
raise TypeError, _("Can only generate execution order on FBD networks!")
setattr(cls, "compileexecutionOrder", compileexecutionOrder)
def compileelementExecutionOrder(self, link):
- if self.content["name"] == "FBD":
+ if self.content.getLocalTag() == "FBD":
localid = link.getrefLocalId()
instance = self.getcontentInstance(localid)
- if isinstance(instance, PLCOpenClasses.get("fbdObjects_block", None)) and instance.getexecutionOrderId() == 0:
+ 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])
instance.setexecutionOrderId(self.getnewExecutionOrderId())
- elif isinstance(instance, PLCOpenClasses.get("commonObjects_continuation", None)) and instance.getexecutionOrderId() == 0:
+ elif isinstance(instance, PLCOpenParser.GetElementClass("continuation", "commonObjects")) and instance.getexecutionOrderId() == 0:
name = instance.getname()
for tmp_instance in self.getcontentInstances():
- if isinstance(tmp_instance, PLCOpenClasses.get("commonObjects_connector", None)) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:
+ if isinstance(tmp_instance, PLCOpenParser.GetElementClass("connector", "commonObjects")) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:
connections = tmp_instance.connectionPointIn.getconnections()
if connections and len(connections) == 1:
self.compileelementExecutionOrder(connections[0])
@@ -1812,124 +1559,125 @@
setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder)
def setelementExecutionOrder(self, instance, new_executionOrder):
- if self.content["name"] == "FBD":
+ if self.content.getLocalTag() == "FBD":
old_executionOrder = instance.getexecutionOrderId()
if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0:
- for element in self.content["value"].getcontent():
- if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("commonObjects_comment", None)):
- element_executionOrder = element["value"].getexecutionOrderId()
+ for element in self.content.getcontent():
+ if element != instance and not isinstance(element, PLCOpenParser.GetElementClass("comment", "commonObjects")):
+ element_executionOrder = element.getexecutionOrderId()
if old_executionOrder <= element_executionOrder <= new_executionOrder:
- element["value"].setexecutionOrderId(element_executionOrder - 1)
+ element.setexecutionOrderId(element_executionOrder - 1)
if new_executionOrder <= element_executionOrder <= old_executionOrder:
- element["value"].setexecutionOrderId(element_executionOrder + 1)
+ element.setexecutionOrderId(element_executionOrder + 1)
instance.setexecutionOrderId(new_executionOrder)
else:
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"]:
- element = {"name" : name, "value" : instance}
- self.content["value"].appendcontent(element)
- self.instances_dict[instance.getlocalId()] = element
+ def appendcontentInstance(self, instance):
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ self.content.appendcontent(instance)
else:
- raise TypeError, _("%s body don't have instances!")%self.content["name"]
+ raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
setattr(cls, "appendcontentInstance", appendcontentInstance)
def getcontentInstances(self):
- if self.content["name"] in ["LD","FBD","SFC"]:
- instances = []
- for element in self.content["value"].getcontent():
- instances.append(element["value"])
- return instances
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ return self.content.getcontent()
else:
- raise TypeError, _("%s body don't have instances!")%self.content["name"]
+ raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
setattr(cls, "getcontentInstances", getcontentInstances)
-
- def getcontentInstance(self, id):
- if self.content["name"] in ["LD","FBD","SFC"]:
- instance = self.instances_dict.get(id, None)
- if instance is not None:
- return instance["value"]
+
+ instance_by_id_xpath = PLCOpen_XPath("*[@localId=$localId]")
+ instance_by_name_xpath = PLCOpen_XPath("ppx:block[@instanceName=$name]")
+ def getcontentInstance(self, local_id):
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ instance = instance_by_id_xpath(self.content, localId=local_id)
+ 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.getLocalTag()
setattr(cls, "getcontentInstance", getcontentInstance)
def getcontentRandomInstance(self, exclude):
- if self.content["name"] in ["LD","FBD","SFC"]:
- ids = self.instances_dict.viewkeys() - exclude
- if len(ids) > 0:
- return self.instances_dict[ids.pop()]["value"]
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ 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.getLocalTag()
setattr(cls, "getcontentRandomInstance", getcontentRandomInstance)
def getcontentInstanceByName(self, name):
- if self.content["name"] in ["LD","FBD","SFC"]:
- for element in self.content["value"].getcontent():
- if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_block", None)) and element["value"].getinstanceName() == name:
- return element["value"]
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ instance = instance_by_name_xpath(self.content)
+ 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.getLocalTag()
setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)
- def removecontentInstance(self, id):
- if self.content["name"] in ["LD","FBD","SFC"]:
- element = self.instances_dict.pop(id, None)
- if element is not None:
- self.content["value"].getcontent().remove(element)
+ def removecontentInstance(self, local_id):
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ instance = instance_by_id_xpath(self.content, localId=local_id)
+ if len(instance) > 0:
+ self.content.remove(instance[0])
else:
raise ValueError, _("Instance with id %d doesn't exist!")%id
else:
- raise TypeError, "%s body don't have instances!"%self.content["name"]
+ raise TypeError, "%s body don't have instances!"%self.content.getLocalTag()
setattr(cls, "removecontentInstance", removecontentInstance)
def settext(self, text):
- if self.content["name"] in ["IL","ST"]:
- self.content["value"].settext(text)
+ if self.content.getLocalTag() in ["IL","ST"]:
+ self.content.setanyText(text)
else:
- raise TypeError, _("%s body don't have text!")%self.content["name"]
+ raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
setattr(cls, "settext", settext)
def gettext(self):
- if self.content["name"] in ["IL","ST"]:
- return self.content["value"].gettext()
+ if self.content.getLocalTag() in ["IL","ST"]:
+ return self.content.getanyText()
else:
- raise TypeError, _("%s body don't have text!")%self.content["name"]
+ raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
setattr(cls, "gettext", gettext)
def hasblock(self, block_type):
- if self.content["name"] in ["IL","ST"]:
- return self.content["value"].hasblock(block_type)
+ if self.content.getLocalTag() in ["IL","ST"]:
+ return self.content.hasblock(block_type)
else:
- raise TypeError, _("%s body don't have text!")%self.content["name"]
+ raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
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)
+ if self.content.getLocalTag() in ["IL", "ST"]:
+ self.content.updateElementName(old_name, new_name)
else:
- for element in self.content["value"].getcontent():
- element["value"].updateElementName(old_name, new_name)
+ for element in self.content.getcontent():
+ element.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.content["name"] in ["IL", "ST"]:
- self.content["value"].updateElementAddress(address_model, new_leading)
+ if self.content.getLocalTag() in ["IL", "ST"]:
+ self.content.updateElementAddress(address_model, new_leading)
else:
- for element in self.content["value"].getcontent():
- element["value"].updateElementAddress(address_model, new_leading)
+ for element in self.content.getcontent():
+ element.updateElementAddress(address_model, new_leading)
setattr(cls, "updateElementAddress", updateElementAddress)
def Search(self, criteria, parent_infos=[]):
- if self.content["name"] in ["IL", "ST"]:
- search_result = self.content["value"].Search(criteria, parent_infos + ["body", 0])
+ if self.content.getLocalTag() in ["IL", "ST"]:
+ search_result = self.content.Search(criteria, parent_infos + ["body", 0])
else:
search_result = []
- for element in self.content["value"].getcontent():
- search_result.extend(element["value"].Search(criteria, parent_infos))
+ for element in self.content.getcontent():
+ search_result.extend(element.Search(criteria, parent_infos))
return search_result
setattr(cls, "Search", Search)
@@ -1972,15 +1720,11 @@
def _filterConnections(connectionPointIn, localId, connections):
in_connections = connectionPointIn.getconnections()
if in_connections is not None:
- to_delete = []
- for i, connection in enumerate(in_connections):
+ for connection in in_connections:
connected = connection.getrefLocalId()
if not connections.has_key((localId, connected)) and \
not connections.has_key((connected, localId)):
- to_delete.append(i)
- to_delete.reverse()
- for i in to_delete:
- connectionPointIn.removeconnection(i)
+ connectionPointIn.remove(connection)
def _filterConnectionsSingle(self, connections):
if self.connectionPointIn is not None:
@@ -1991,8 +1735,8 @@
_filterConnections(connectionPointIn, self.localId, connections)
def _getconnectionsdefinition(instance, connections_end):
- id = instance.getlocalId()
- return dict([((id, end), True) for end in connections_end])
+ local_id = instance.getlocalId()
+ return dict([((local_id, end), True) for end in connections_end])
def _updateConnectionsId(connectionPointIn, translation):
connections_end = []
@@ -2063,9 +1807,8 @@
"multiple": _updateConnectionsIdMultiple},
}
-def _initElementClass(name, classname, connectionPointInType="none"):
- ElementNameToClass[name] = classname
- cls = PLCOpenClasses.get(classname, None)
+def _initElementClass(name, parent, connectionPointInType="none"):
+ cls = PLCOpenParser.GetElementClass(name, parent)
if cls:
setattr(cls, "getx", getx)
setattr(cls, "gety", gety)
@@ -2146,7 +1889,7 @@
return getvariableinfos
def _getconnectorinfosFunction(type):
- def getvariableinfos(self):
+ def getconnectorinfos(self):
infos = _getelementinfos(self)
infos["type"] = type
infos["specific_values"]["name"] = self.getname()
@@ -2155,7 +1898,7 @@
elif type == "continuation":
infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))
return infos
- return getvariableinfos
+ return getconnectorinfos
def _getpowerrailinfosFunction(type):
def getpowerrailinfos(self):
@@ -2172,16 +1915,16 @@
return infos
return getpowerrailinfos
-def _getldelementinfosFunction(type):
+def _getldelementinfosFunction(ld_element_type):
def getldelementinfos(self):
infos = _getelementinfos(self)
- infos["type"] = type
+ infos["type"] = ld_element_type
specific_values = infos["specific_values"]
specific_values["name"] = self.getvariable()
_getexecutionOrder(self, specific_values)
specific_values["negated"] = self.getnegated()
specific_values["edge"] = self.getedge()
- if type == "coil":
+ if ld_element_type == "coil":
specific_values["storage"] = self.getstorage()
infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True))
infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))
@@ -2210,7 +1953,7 @@
return infos
return getdivergenceinfos
-cls = _initElementClass("comment", "commonObjects_comment")
+cls = _initElementClass("comment", "commonObjects")
if cls:
def getinfos(self):
infos = _getelementinfos(self)
@@ -2220,11 +1963,11 @@
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):
@@ -2239,7 +1982,7 @@
return self.content.Search(criteria, parent_infos + ["comment", self.getlocalId(), "content"])
setattr(cls, "Search", Search)
-cls = _initElementClass("block", "fbdObjects_block")
+cls = _initElementClass("block", "fbdObjects")
if cls:
def getBoundingBox(self):
bbox = _getBoundingBox(self)
@@ -2298,49 +2041,41 @@
return search_result
setattr(cls, "Search", Search)
-cls = _initElementClass("leftPowerRail", "ldObjects_leftPowerRail")
+cls = _initElementClass("leftPowerRail", "ldObjects")
if cls:
setattr(cls, "getinfos", _getpowerrailinfosFunction("leftPowerRail"))
-cls = _initElementClass("rightPowerRail", "ldObjects_rightPowerRail", "multiple")
+cls = _initElementClass("rightPowerRail", "ldObjects", "multiple")
if cls:
setattr(cls, "getinfos", _getpowerrailinfosFunction("rightPowerRail"))
-cls = _initElementClass("contact", "ldObjects_contact", "single")
+def _UpdateLDElementName(self, old_name, new_name):
+ if 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 _getSearchInLDElement(ld_element_type):
+ 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, "getinfos", _getldelementinfosFunction("contact"))
-
- def updateElementName(self, old_name, new_name):
- if self.variable == old_name:
- self.variable = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.variable = update_address(self.variable, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
- def Search(self, criteria, parent_infos=[]):
- return _Search([("reference", self.getvariable())], criteria, parent_infos + ["contact", self.getlocalId()])
- setattr(cls, "Search", Search)
-
-cls = _initElementClass("coil", "ldObjects_coil", "single")
+ setattr(cls, "updateElementName", _UpdateLDElementName)
+ setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
+ setattr(cls, "Search", _getSearchInLDElement("contact"))
+
+cls = _initElementClass("coil", "ldObjects", "single")
if cls:
setattr(cls, "getinfos", _getldelementinfosFunction("coil"))
-
- def updateElementName(self, old_name, new_name):
- if self.variable == old_name:
- self.variable = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.variable = update_address(self.variable, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
- def Search(self, criteria, parent_infos=[]):
- return _Search([("reference", self.getvariable())], criteria, parent_infos + ["coil", self.getlocalId()])
- setattr(cls, "Search", Search)
-
-cls = _initElementClass("step", "sfcObjects_step", "single")
+ setattr(cls, "updateElementName", _UpdateLDElementName)
+ setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
+ setattr(cls, "Search", _getSearchInLDElement("coil"))
+
+cls = _initElementClass("step", "sfcObjects", "single")
if cls:
def getinfos(self):
infos = _getelementinfos(self)
@@ -2348,11 +2083,11 @@
specific_values = infos["specific_values"]
specific_values["name"] = self.getname()
specific_values["initial"] = self.getinitialStep()
- if self.connectionPointIn:
+ if self.connectionPointIn is not None:
infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True))
- if self.connectionPointOut:
+ if self.connectionPointOut is not None:
infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))
- if self.connectionPointOutAction:
+ if self.connectionPointOutAction is not None:
specific_values["action"] = _getconnectioninfos(self, self.connectionPointOutAction)
return infos
setattr(cls, "getinfos", getinfos)
@@ -2361,7 +2096,7 @@
return _Search([("name", self.getname())], criteria, parent_infos + ["step", self.getlocalId()])
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("transition_condition", None)
+cls = PLCOpenParser.GetElementClass("condition", "transition")
if cls:
def compatibility(self, tree):
connections = []
@@ -2378,7 +2113,7 @@
tree.childNodes = [node]
setattr(cls, "compatibility", compatibility)
-cls = _initElementClass("transition", "sfcObjects_transition")
+cls = _initElementClass("transition", "sfcObjects")
if cls:
def getinfos(self):
infos = _getelementinfos(self)
@@ -2399,49 +2134,48 @@
return infos
setattr(cls, "getinfos", getinfos)
- def setconditionContent(self, type, value):
- if not self.condition:
+ def setconditionContent(self, condition_type, value):
+ if self.condition is None:
self.addcondition()
- if type == "reference":
- condition = PLCOpenClasses["condition_reference"]()
+ if condition_type == "connection":
+ condition = PLCOpenParser.CreateElement("connectionPointIn", "condition")
+ else:
+ condition = PLCOpenParser.CreateElement(condition_type, "condition")
+ self.condition.setcontent(condition)
+ if condition_type == "reference":
condition.setname(value)
- elif type == "inline":
- condition = PLCOpenClasses["condition_inline"]()
- condition.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
+ elif condition_type == "inline":
+ condition.setcontent(PLCOpenParser.CreateElement("ST", "inline"))
condition.settext(value)
- elif type == "connection":
- type = "connectionPointIn"
- condition = PLCOpenClasses["connectionPointIn"]()
- self.condition.setcontent({"name" : type, "value" : condition})
setattr(cls, "setconditionContent", setconditionContent)
def getconditionContent(self):
- if self.condition:
+ if self.condition is not None:
content = self.condition.getcontent()
- values = {"type" : content["name"]}
+ values = {"type" : content.getLocalTag()}
if values["type"] == "reference":
- values["value"] = content["value"].getname()
+ values["value"] = content.getname()
elif values["type"] == "inline":
- values["value"] = content["value"].gettext()
+ values["value"] = content.gettext()
elif values["type"] == "connectionPointIn":
values["type"] = "connection"
- values["value"] = content["value"]
+ values["value"] = content
return values
return ""
setattr(cls, "getconditionContent", getconditionContent)
def getconditionConnection(self):
- if self.condition:
+ if self.condition is not None:
content = self.condition.getcontent()
- if content["name"] == "connectionPointIn":
- return content["value"]
+ if content.getLocalTag() == "connectionPointIn":
+ return content
return None
setattr(cls, "getconditionConnection", getconditionConnection)
def getBoundingBox(self):
bbox = _getBoundingBoxSingle(self)
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
bbox.union(_getConnectionsBoundingBox(condition_connection))
return bbox
setattr(cls, "getBoundingBox", getBoundingBox)
@@ -2449,14 +2183,14 @@
def translate(self, dx, dy):
_translateSingle(self, dx, dy)
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
_translateConnections(condition_connection, dx, dy)
setattr(cls, "translate", translate)
def filterConnections(self, connections):
_filterConnectionsSingle(self, connections)
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
_filterConnections(condition_connection, self.localId, connections)
setattr(cls, "filterConnections", filterConnections)
@@ -2465,33 +2199,35 @@
if self.connectionPointIn is not None:
connections_end = _updateConnectionsId(self.connectionPointIn, translation)
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
connections_end.extend(_updateConnectionsId(condition_connection, translation))
return _getconnectionsdefinition(self, connections_end)
setattr(cls, "updateConnectionsId", updateConnectionsId)
def updateElementName(self, old_name, new_name):
- if self.condition:
+ if self.condition is not None:
content = self.condition.getcontent()
- if content["name"] == "reference":
- if content["value"].getname() == old_name:
- content["value"].setname(new_name)
- elif content["name"] == "inline":
- content["value"].updateElementName(old_name, new_name)
+ content_name = content.getLocalTag()
+ if content_name == "reference":
+ if content.getname() == old_name:
+ content.setname(new_name)
+ elif content_name == "inline":
+ content.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.condition:
+ if self.condition is not None:
content = self.condition.getcontent()
- if content["name"] == "reference":
- content["value"].setname(update_address(content["value"].getname(), address_model, new_leading))
- elif content["name"] == "inline":
- content["value"].updateElementAddress(address_model, new_leading)
+ content_name = content.getLocalTag()
+ if content_name == "reference":
+ content.setname(update_address(content.getname(), address_model, new_leading))
+ elif content_name == "inline":
+ content.updateElementAddress(address_model, new_leading)
setattr(cls, "updateElementAddress", updateElementAddress)
def getconnections(self):
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
return condition_connection.getconnections()
return None
setattr(cls, "getconnections", getconnections)
@@ -2500,30 +2236,31 @@
parent_infos = parent_infos + ["transition", self.getlocalId()]
search_result = []
content = self.condition.getcontent()
- if content["name"] == "reference":
- search_result.extend(_Search([("reference", content["value"].getname())], criteria, parent_infos))
- elif content["name"] == "inline":
- search_result.extend(content["value"].Search(criteria, parent_infos + ["inline"]))
+ content_name = content.getLocalTag()
+ if content_name == "reference":
+ search_result.extend(_Search([("reference", content.getname())], criteria, parent_infos))
+ 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)
@@ -2537,7 +2274,7 @@
return _Search([("target", self.gettargetName())], criteria, parent_infos + ["jump", self.getlocalId()])
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("actionBlock_action", None)
+cls = PLCOpenParser.GetElementClass("action", "actionBlock")
if cls:
def compatibility(self, tree):
relPosition = reduce(lambda x, y: x | (y.nodeName == "relPosition"), tree.childNodes, False)
@@ -2551,39 +2288,39 @@
setattr(cls, "compatibility", compatibility)
def setreferenceName(self, name):
- if self.reference:
+ if self.reference is not None:
self.reference.setname(name)
setattr(cls, "setreferenceName", setreferenceName)
def getreferenceName(self):
- if self.reference:
+ if self.reference is not None:
return self.reference.getname()
return None
setattr(cls, "getreferenceName", getreferenceName)
def setinlineContent(self, content):
- if self.inline:
- self.inline.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
+ if self.inline is not None:
+ self.inline.setcontent(PLCOpenParser.CreateElement("ST", "inline"))
self.inline.settext(content)
setattr(cls, "setinlineContent", setinlineContent)
def getinlineContent(self):
- if self.inline:
+ if self.inline is not None:
return self.inline.gettext()
return None
setattr(cls, "getinlineContent", getinlineContent)
def updateElementName(self, old_name, new_name):
- if self.reference and self.reference.getname() == old_name:
+ if self.reference is not None and self.reference.getname() == old_name:
self.reference.setname(new_name)
- if self.inline:
+ if self.inline is not None:
self.inline.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.reference:
+ if self.reference is not None:
self.reference.setname(update_address(self.reference.getname(), address_model, new_leading))
- if self.inline:
+ if self.inline is not None:
self.inline.updateElementAddress(address_model, new_leading)
setattr(cls, "updateElementAddress", updateElementAddress)
@@ -2599,7 +2336,7 @@
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[:]:
@@ -2618,7 +2355,8 @@
def setactions(self, actions):
self.action = []
for params in actions:
- action = PLCOpenClasses["actionBlock_action"]()
+ action = PLCOpenParser.CreateElement("action", "actionBlock")
+ self.appendaction(action)
action.setqualifier(params["qualifier"])
if params["type"] == "reference":
action.addreference()
@@ -2630,7 +2368,6 @@
action.setduration(params["duration"])
if params.has_key("indicator"):
action.setindicator(params["indicator"])
- self.action.append(action)
setattr(cls, "setactions", setactions)
def getactions(self):
@@ -2640,17 +2377,17 @@
params["qualifier"] = action.getqualifier()
if params["qualifier"] is None:
params["qualifier"] = "N"
- if action.getreference():
+ if action.getreference() is not None:
params["type"] = "reference"
params["value"] = action.getreferenceName()
- elif action.getinline():
+ elif action.getinline() is not None:
params["type"] = "inline"
params["value"] = action.getinlineContent()
duration = action.getduration()
if duration:
params["duration"] = duration
indicator = action.getindicator()
- if indicator:
+ if indicator is not None:
params["indicator"] = indicator
actions.append(params)
return actions
@@ -2675,58 +2412,41 @@
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")
+ return _Search([("expression", self.expression)], criteria, parent_infos + ["io_variable", self.getlocalId()])
+
+def _UpdateIOElementName(self, old_name, new_name):
+ if self.expression == old_name:
+ self.expression = new_name
+
+def _UpdateIOElementAddress(self, old_name, new_name):
+ self.expression = update_address(self.expression, address_model, new_leading)
+
+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 = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.expression = update_address(self.expression, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
+ setattr(cls, "updateElementName", _UpdateIOElementName)
+ setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
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 = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.expression = update_address(self.expression, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
+ setattr(cls, "updateElementName", _UpdateIOElementName)
+ setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
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:
- self.expression = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.expression = update_address(self.expression, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
+ setattr(cls, "updateElementName", _UpdateIOElementName)
+ setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
setattr(cls, "Search", _SearchInIOVariable)
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)
@@ -2736,7 +2456,7 @@
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)
@@ -2746,15 +2466,16 @@
self.name = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("connection", None)
+cls = PLCOpenParser.GetElementClass("connection")
if cls:
def setpoints(self, points):
- self.position = []
+ positions = []
for point in points:
- position = PLCOpenClasses["position"]()
+ position = PLCOpenParser.CreateElement("position", "connection")
position.setx(point.x)
position.sety(point.y)
- self.position.append(position)
+ positions.append(position)
+ self.position = positions
setattr(cls, "setpoints", setpoints)
def getpoints(self):
@@ -2764,111 +2485,115 @@
return points
setattr(cls, "getpoints", getpoints)
-cls = PLCOpenClasses.get("connectionPointIn", None)
+cls = PLCOpenParser.GetElementClass("connectionPointIn")
if cls:
def setrelPositionXY(self, x, y):
- self.relPosition = PLCOpenClasses["position"]()
+ self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointIn")
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):
- if not self.content:
- self.content = {"name" : "connection", "value" : [PLCOpenClasses["connection"]()]}
- else:
- self.content["value"].append(PLCOpenClasses["connection"]())
+ self.append(PLCOpenParser.CreateElement("connection", "connectionPointIn"))
setattr(cls, "addconnection", addconnection)
def removeconnection(self, idx):
- if self.content:
- self.content["value"].pop(idx)
- if len(self.content["value"]) == 0:
- self.content = None
+ if len(self.content) > idx:
+ self.remove(self.content[idx])
setattr(cls, "removeconnection", removeconnection)
def removeconnections(self):
- if self.content:
- self.content = None
+ self.content = None
setattr(cls, "removeconnections", removeconnections)
+ connection_xpath = PLCOpen_XPath("ppx:connection")
+ connection_by_position_xpath = PLCOpen_XPath("ppx:connection[position()=$pos]")
def getconnections(self):
- if self.content:
- return self.content["value"]
- return []
+ return connection_xpath(self)
setattr(cls, "getconnections", getconnections)
- def setconnectionId(self, idx, id):
- if self.content:
- self.content["value"][idx].setrefLocalId(id)
+ def getconnection(self, idx):
+ connection = connection_by_position_xpath(self, pos=idx+1)
+ if len(connection) > 0:
+ return connection[0]
+ return None
+ setattr(cls, "getconnection", getconnection)
+
+ def setconnectionId(self, idx, local_id):
+ connection = self.getconnection(idx)
+ if connection is not None:
+ connection.setrefLocalId(local_id)
setattr(cls, "setconnectionId", setconnectionId)
def getconnectionId(self, idx):
- if self.content:
- return self.content["value"][idx].getrefLocalId()
+ connection = self.getconnection(idx)
+ if connection is not None:
+ return connection.getrefLocalId()
return None
setattr(cls, "getconnectionId", getconnectionId)
def setconnectionPoints(self, idx, points):
- if self.content:
- self.content["value"][idx].setpoints(points)
+ connection = self.getconnection(idx)
+ if connection is not None:
+ connection.setpoints(points)
setattr(cls, "setconnectionPoints", setconnectionPoints)
def getconnectionPoints(self, idx):
- if self.content:
- return self.content["value"][idx].getpoints()
+ connection = self.getconnection(idx)
+ if connection is not None:
+ return connection.getpoints()
return []
setattr(cls, "getconnectionPoints", getconnectionPoints)
def setconnectionParameter(self, idx, parameter):
- if self.content:
- self.content["value"][idx].setformalParameter(parameter)
+ connection = self.getconnection(idx)
+ if connection is not None:
+ connection.setformalParameter(parameter)
setattr(cls, "setconnectionParameter", setconnectionParameter)
def getconnectionParameter(self, idx):
- if self.content:
- return self.content["value"][idx].getformalParameter()
+ connection = self.getconnection(idx)
+ if connection is not None:
+ return connection.getformalParameter()
return None
setattr(cls, "getconnectionParameter", getconnectionParameter)
-cls = PLCOpenClasses.get("connectionPointOut", None)
+cls = PLCOpenParser.GetElementClass("connectionPointOut")
if cls:
def setrelPositionXY(self, x, y):
- self.relPosition = PLCOpenClasses["position"]()
+ self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointOut")
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 = PLCOpenClasses.get("value", None)
+cls = PLCOpenParser.GetElementClass("value")
if cls:
def setvalue(self, value):
value = value.strip()
if value.startswith("[") and value.endswith("]"):
- arrayValue = PLCOpenClasses["value_arrayValue"]()
- self.content = {"name" : "arrayValue", "value" : arrayValue}
+ content = PLCOpenParser.CreateElement("arrayValue", "value")
elif value.startswith("(") and value.endswith(")"):
- structValue = PLCOpenClasses["value_structValue"]()
- self.content = {"name" : "structValue", "value" : structValue}
+ content = PLCOpenParser.CreateElement("structValue", "value")
else:
- simpleValue = PLCOpenClasses["value_simpleValue"]()
- self.content = {"name" : "simpleValue", "value": simpleValue}
- self.content["value"].setvalue(value)
+ content = PLCOpenParser.CreateElement("simpleValue", "value")
+ content.setvalue(value)
+ self.setcontent(content)
setattr(cls, "setvalue", setvalue)
def getvalue(self):
- return self.content["value"].getvalue()
+ return self.content.getvalue()
setattr(cls, "getvalue", getvalue)
def extractValues(values):
@@ -2885,15 +2610,15 @@
raise ValueError, _("\"%s\" is an invalid value!")%value
return items
-cls = PLCOpenClasses.get("value_arrayValue", None)
+cls = PLCOpenParser.GetElementClass("arrayValue", "value")
if cls:
arrayValue_model = re.compile("([0-9]*)\((.*)\)$")
def setvalue(self, value):
- self.value = []
+ elements = []
for item in extractValues(value[1:-1]):
item = item.strip()
- element = PLCOpenClasses["arrayValue_value"]()
+ element = PLCOpenParser.CreateElement("value", "arrayValue")
result = arrayValue_model.match(item)
if result is not None:
groups = result.groups()
@@ -2901,14 +2626,18 @@
element.setvalue(groups[1].strip())
else:
element.setvalue(item)
- self.value.append(element)
+ elements.append(element)
+ self.value = elements
setattr(cls, "setvalue", setvalue)
def getvalue(self):
values = []
for element in self.value:
- repetition = element.getrepetitionValue()
- if repetition is not None and int(repetition) > 1:
+ try:
+ repetition = int(element.getrepetitionValue())
+ except:
+ repetition = 1
+ if repetition > 1:
value = element.getvalue()
if value is None:
value = ""
@@ -2918,20 +2647,21 @@
return "[%s]"%", ".join(values)
setattr(cls, "getvalue", getvalue)
-cls = PLCOpenClasses.get("value_structValue", None)
+cls = PLCOpenParser.GetElementClass("structValue", "value")
if cls:
structValue_model = re.compile("(.*):=(.*)")
def setvalue(self, value):
- self.value = []
+ elements = []
for item in extractValues(value[1:-1]):
result = structValue_model.match(item)
if result is not None:
groups = result.groups()
- element = PLCOpenClasses["structValue_value"]()
+ element = PLCOpenParser.CreateElement("value", "structValue")
element.setmember(groups[0].strip())
element.setvalue(groups[1].strip())
- self.value.append(element)
+ elements.append(element)
+ self.value = elements
setattr(cls, "setvalue", setvalue)
def getvalue(self):
@@ -2940,3 +2670,4 @@
values.append("%s := %s"%(element.getmember(), element.getvalue()))
return "(%s)"%", ".join(values)
setattr(cls, "getvalue", getvalue)
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plcopen/pou_variables.xslt Fri Sep 27 09:32:39 2013 +0900
@@ -0,0 +1,219 @@
+<xsl:stylesheet version="1.0"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+ xmlns:ppx="http://www.plcopen.org/xml/tc6_0201"
+ xmlns:ns="pou_vars_ns"
+ extension-element-prefixes="ns"
+ exclude-result-prefixes="ns">
+ <xsl:template match="ppx:pou">
+ <pou>
+ <class><xsl:value-of select="@pouType"/></class>
+ <type><xsl:value-of select="@name"/></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>True</xsl:text></debug>
+ <variables>
+ <xsl:apply-templates select="ppx:interface"/>
+ <xsl:apply-templates select="ppx:actions/ppx:action | ppx:transitions/ppx:transition" mode="variable_list"/>
+ </variables>
+ </pou>
+ </xsl:template>
+ <xsl:template match="ppx:action">
+ <action>
+ <class/>
+ <type><xsl:text>None</xsl:text></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>True</xsl:text></debug>
+ <variables>
+ <xsl:apply-templates select="ancestor::ppx:pou/child::ppx:interface"/>
+ </variables>
+ </action>
+ </xsl:template>
+ <xsl:template match="ppx:transition">
+ <transition>
+ <class/>
+ <type><xsl:text>None</xsl:text></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>True</xsl:text></debug>
+ <variables>
+ <xsl:apply-templates select="ancestor::ppx:pou/child::ppx:interface"/>
+ </variables>
+ </transition>
+ </xsl:template>
+ <xsl:template match="ppx:configuration">
+ <configuration>
+ <class/>
+ <type><xsl:text>None</xsl:text></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>False</xsl:text></debug>
+ <variables>
+ <xsl:apply-templates select="ppx:resource" mode="variable_list"/>
+ <xsl:apply-templates select="ppx:globalVars"/>
+ </variables>
+ </configuration>
+ </xsl:template>
+ <xsl:template match="ppx:resource">
+ <resource>
+ <class/>
+ <type><xsl:text>None</xsl:text></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>False</xsl:text></debug>
+ <variables>
+ <xsl:apply-templates select="ppx:pouInstance | ppx:task/ppx:pouInstance" mode="variable_list"/>
+ <xsl:apply-templates select="ppx:globalVars"/>
+ </variables>
+ </resource>
+ </xsl:template>
+ <xsl:template match="ppx:localVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Local'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:globalVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Global'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:externalVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'External'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:tempVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Temp'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:inputVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Input'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:outputVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Output'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:inOutVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'InOut'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template name="variables_infos">
+ <xsl:param name="var_class"/>
+ <xsl:for-each select="ppx:variable">
+ <variable>
+ <name><xsl:value-of select="@name"/></name>
+ <class>
+ <xsl:apply-templates mode="var_class">
+ <xsl:with-param name="default_class">
+ <xsl:value-of select="$var_class"/>
+ </xsl:with-param>
+ </xsl:apply-templates>
+ </class>
+ <type><xsl:apply-templates mode="var_type"/></type>
+ <edit><xsl:apply-templates mode="var_edit"/></edit>
+ <debug><xsl:apply-templates mode="var_debug"/></debug>
+ </variable>
+ </xsl:for-each>
+ </xsl:template>
+ <xsl:template match="ppx:transition" mode="variable_list">
+ <transition>
+ <name><xsl:value-of select="@name"/></name>
+ <class/>
+ <type><xsl:text>None</xsl:text></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>True</xsl:text></debug>
+ </transition>
+ </xsl:template>
+ <xsl:template match="ppx:action" mode="variable_list">
+ <action>
+ <name><xsl:value-of select="@name"/></name>
+ <class/>
+ <type><xsl:text>None</xsl:text></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>True</xsl:text></debug>
+ </action>
+ </xsl:template>
+ <xsl:template match="ppx:resource" mode="variable_list">
+ <resource>
+ <name><xsl:value-of select="@name"/></name>
+ <class/>
+ <type><xsl:text>None</xsl:text></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>False</xsl:text></debug>
+ </resource>
+ </xsl:template>
+ <xsl:template match="ppx:pouInstance" mode="variable_list">
+ <program>
+ <name><xsl:value-of select="@name"/></name>
+ <class/>
+ <type><xsl:value-of select="@typeName"/></type>
+ <edit><xsl:text>True</xsl:text></edit>
+ <debug><xsl:text>True</xsl:text></debug>
+ </program>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:derived" mode="var_class">
+ <xsl:param name="default_class"/>
+ <ns:pou_class>
+ <xsl:value-of select="$default_class"/>
+ </ns:pou_class>
+ </xsl:template>
+ <xsl:template match="ppx:pou" mode="var_class">
+ <xsl:param name="default_class"/>
+ <xsl:value-of select="@pouType"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/*" mode="var_class">
+ <xsl:param name="default_class"/>
+ <xsl:value-of select="$default_class"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:derived" mode="var_type">
+ <xsl:value-of select="@name"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:array" mode="var_type">
+ <xsl:text>ARRAY [</xsl:text>
+ <xsl:for-each select="ppx:dimension">
+ <xsl:value-of select="@lower"/>
+ <xsl:text>..</xsl:text>
+ <xsl:value-of select="@upper"/>
+ </xsl:for-each>
+ <xsl:text>] OF </xsl:text>
+ <xsl:apply-templates select="ppx:baseType" mode="var_type"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:string" mode="var_type">
+ <xsl:text>STRING</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:wstring" mode="var_type">
+ <xsl:text>WSTRING</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/*" mode="var_type">
+ <xsl:value-of select="local-name()"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:derived" mode="var_edit">
+ <ns:is_edited/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:array" mode="var_edit">
+ <xsl:apply-templates select="ppx:baseType" mode="var_edit"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/*" mode="var_edit">
+ <xsl:text>False</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:derived" mode="var_debug">
+ <ns:is_debugged/>
+ </xsl:template>
+ <xsl:template match="ppx:pou" mode="var_debug">
+ <xsl:text>True</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:array" mode="var_debug">
+ <xsl:text>False</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/ppx:struct" mode="var_debug">
+ <xsl:text>False</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType]/*" mode="var_debug">
+ <xsl:text>True</xsl:text>
+ </xsl:template>
+ <xsl:template match="text()"/>
+ <xsl:template match="text()" mode="var_class"/>
+ <xsl:template match="text()" mode="var_type"/>
+ <xsl:template match="text()" mode="var_edit"/>
+ <xsl:template match="text()" mode="var_debug"/>
+</xsl:stylesheet>
\ No newline at end of file
--- a/plcopen/structures.py Thu Sep 26 20:47:36 2013 +0900
+++ b/plcopen/structures.py Fri Sep 27 09:32:39 2013 +0900
@@ -23,6 +23,8 @@
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import string, os, sys, re
+from plcopen import LoadProject
+from collections import OrderedDict
LANGUAGES = ["IL","ST","FBD","LD","SFC"]
@@ -34,205 +36,48 @@
_ = lambda x:x
-# Helper for emulate join on element list
-def JoinList(separator, mylist):
- if len(mylist) > 0 :
- return reduce(lambda x, y: x + separator + y, mylist)
- else :
- return mylist
-
-def generate_block(generator, block, block_infos, body, link, order=False, to_inout=False):
- body_type = body.getcontent()["name"]
- name = block.getinstanceName()
- type = block.gettypeName()
- executionOrderId = block.getexecutionOrderId()
- input_variables = block.inputVariables.getvariable()
- output_variables = block.outputVariables.getvariable()
- inout_variables = {}
- for input_variable in input_variables:
- for output_variable in output_variables:
- if input_variable.getformalParameter() == output_variable.getformalParameter():
- inout_variables[input_variable.getformalParameter()] = ""
- input_names = [input[0] for input in block_infos["inputs"]]
- output_names = [output[0] for output in block_infos["outputs"]]
- if block_infos["type"] == "function":
- if not generator.ComputedBlocks.get(block, False) and not order:
- generator.ComputedBlocks[block] = True
- connected_vars = []
- if not block_infos["extensible"]:
- input_connected = dict([("EN", None)] +
- [(input_name, None) for input_name in input_names])
- for variable in input_variables:
- parameter = variable.getformalParameter()
- if input_connected.has_key(parameter):
- input_connected[parameter] = variable
- if input_connected["EN"] is None:
- input_connected.pop("EN")
- input_parameters = input_names
- else:
- input_parameters = ["EN"] + input_names
- else:
- input_connected = dict([(variable.getformalParameter(), variable)
- for variable in input_variables])
- input_parameters = [variable.getformalParameter()
- for variable in input_variables]
- one_input_connected = False
- all_input_connected = True
- for i, parameter in enumerate(input_parameters):
- variable = input_connected.get(parameter)
- if variable is not None:
- input_info = (generator.TagName, "block", block.getlocalId(), "input", i)
- connections = variable.connectionPointIn.getconnections()
- if connections is not None:
- if parameter != "EN":
- one_input_connected = True
- if inout_variables.has_key(parameter):
- expression = generator.ComputeExpression(body, connections, executionOrderId > 0, True)
- if expression is not None:
- inout_variables[parameter] = value
- else:
- expression = generator.ComputeExpression(body, connections, executionOrderId > 0)
- if expression is not None:
- connected_vars.append(([(parameter, input_info), (" := ", ())],
- generator.ExtractModifier(variable, expression, input_info)))
- else:
- all_input_connected = False
- else:
- all_input_connected = False
- if len(output_variables) > 1 or not all_input_connected:
- vars = [name + value for name, value in connected_vars]
- else:
- vars = [value for name, value in connected_vars]
- if one_input_connected:
- for i, variable in enumerate(output_variables):
- parameter = variable.getformalParameter()
- if not inout_variables.has_key(parameter) and parameter in output_names + ["", "ENO"]:
- if variable.getformalParameter() == "":
- variable_name = "%s%d"%(type, block.getlocalId())
- else:
- variable_name = "%s%d_%s"%(type, block.getlocalId(), parameter)
- if generator.Interface[-1][0] != "VAR" or generator.Interface[-1][1] is not None or generator.Interface[-1][2]:
- generator.Interface.append(("VAR", None, False, []))
- if variable.connectionPointOut in generator.ConnectionTypes:
- generator.Interface[-1][3].append((generator.ConnectionTypes[variable.connectionPointOut], variable_name, None, None))
- else:
- generator.Interface[-1][3].append(("ANY", variable_name, None, None))
- if len(output_variables) > 1 and parameter not in ["", "OUT"]:
- vars.append([(parameter, (generator.TagName, "block", block.getlocalId(), "output", i)),
- (" => %s"%variable_name, ())])
- else:
- output_info = (generator.TagName, "block", block.getlocalId(), "output", i)
- output_name = variable_name
- generator.Program += [(generator.CurrentIndent, ()),
- (output_name, output_info),
- (" := ", ()),
- (type, (generator.TagName, "block", block.getlocalId(), "type")),
- ("(", ())]
- generator.Program += JoinList([(", ", ())], vars)
- generator.Program += [(");\n", ())]
- else:
- generator.Warnings.append(_("\"%s\" function cancelled in \"%s\" POU: No input connected")%(type, generator.TagName.split("::")[-1]))
- elif block_infos["type"] == "functionBlock":
- if not generator.ComputedBlocks.get(block, False) and not order:
- generator.ComputedBlocks[block] = True
- vars = []
- offset_idx = 0
- for variable in input_variables:
- parameter = variable.getformalParameter()
- if parameter in input_names or parameter == "EN":
- if parameter == "EN":
- input_idx = 0
- offset_idx = 1
- else:
- input_idx = offset_idx + input_names.index(parameter)
- input_info = (generator.TagName, "block", block.getlocalId(), "input", input_idx)
- connections = variable.connectionPointIn.getconnections()
- if connections is not None:
- expression = generator.ComputeExpression(body, connections, executionOrderId > 0, inout_variables.has_key(parameter))
- if expression is not None:
- vars.append([(parameter, input_info),
- (" := ", ())] + generator.ExtractModifier(variable, expression, input_info))
- generator.Program += [(generator.CurrentIndent, ()),
- (name, (generator.TagName, "block", block.getlocalId(), "name")),
- ("(", ())]
- generator.Program += JoinList([(", ", ())], vars)
- generator.Program += [(");\n", ())]
-
- if link:
- connectionPoint = link.getposition()[-1]
- output_parameter = link.getformalParameter()
- else:
- connectionPoint = None
- output_parameter = None
-
- output_variable = None
- output_idx = 0
- if output_parameter is not None:
- if output_parameter in output_names or output_parameter == "ENO":
- for variable in output_variables:
- if variable.getformalParameter() == output_parameter:
- output_variable = variable
- if output_parameter != "ENO":
- output_idx = output_names.index(output_parameter)
- else:
- for i, variable in enumerate(output_variables):
- blockPointx, blockPointy = variable.connectionPointOut.getrelPositionXY()
- if (not connectionPoint or
- block.getx() + blockPointx == connectionPoint.getx() and
- block.gety() + blockPointy == connectionPoint.gety()):
- output_variable = variable
- output_parameter = variable.getformalParameter()
- output_idx = i
-
- if output_variable is not None:
- if block_infos["type"] == "function":
- output_info = (generator.TagName, "block", block.getlocalId(), "output", output_idx)
- if inout_variables.has_key(output_parameter):
- output_value = inout_variables[output_parameter]
- else:
- if output_parameter == "":
- output_name = "%s%d"%(type, block.getlocalId())
- else:
- output_name = "%s%d_%s"%(type, block.getlocalId(), output_parameter)
- output_value = [(output_name, output_info)]
- return generator.ExtractModifier(output_variable, output_value, output_info)
-
- if block_infos["type"] == "functionBlock":
- output_info = (generator.TagName, "block", block.getlocalId(), "output", output_idx)
- output_name = generator.ExtractModifier(output_variable, [("%s.%s"%(name, output_parameter), output_info)], output_info)
- if to_inout:
- variable_name = "%s_%s"%(name, output_parameter)
- if not generator.IsAlreadyDefined(variable_name):
- if generator.Interface[-1][0] != "VAR" or generator.Interface[-1][1] is not None or generator.Interface[-1][2]:
- generator.Interface.append(("VAR", None, False, []))
- if variable.connectionPointOut in generator.ConnectionTypes:
- generator.Interface[-1][3].append(
- (generator.ConnectionTypes[output_variable.connectionPointOut], variable_name, None, None))
- else:
- generator.Interface[-1][3].append(("ANY", variable_name, None, None))
- generator.Program += [(generator.CurrentIndent, ()),
- ("%s := "%variable_name, ())]
- generator.Program += output_name
- generator.Program += [(";\n", ())]
- return [(variable_name, ())]
- return output_name
- if link is not None:
- if output_parameter is None:
- output_parameter = ""
- if name:
- blockname = "%s(%s)" % (name, type)
- else:
- blockname = type
- raise ValueError, _("No output %s variable found in block %s in POU %s. Connection must be broken") % \
- (output_parameter, blockname, generator.Name)
-
-def initialise_block(type, name, block = None):
- return [(type, name, None, None)]
-
#-------------------------------------------------------------------------------
# Function Block Types definitions
#-------------------------------------------------------------------------------
+ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]
+
+StdBlockLibrary = LoadProject(os.path.join(ScriptDirectory, "Standard_Function_Blocks.xml"))
+AddnlBlockLibrary = LoadProject(os.path.join(ScriptDirectory, "Additional_Function_Blocks.xml"))
+
+StdBlockComments = {
+ "SR": _("SR bistable\nThe SR bistable is a latch where the Set dominates."),
+ "RS": _("RS bistable\nThe RS bistable is a latch where the Reset dominates."),
+ "SEMA": _("Semaphore\nThe semaphore provides a mechanism to allow software elements mutually exclusive access to certain ressources."),
+ "R_TRIG": _("Rising edge detector\nThe output produces a single pulse when a rising edge is detected."),
+ "F_TRIG": _("Falling edge detector\nThe output produces a single pulse when a falling edge is detected."),
+ "CTU": _("Up-counter\nThe up-counter can be used to signal when a count has reached a maximum value."),
+ "CTD": _("Down-counter\nThe down-counter can be used to signal when a count has reached zero, on counting down from a preset value."),
+ "CTUD": _("Up-down counter\nThe up-down counter has two inputs CU and CD. It can be used to both count up on one input and down on the other."),
+ "TP": _("Pulse timer\nThe pulse timer can be used to generate output pulses of a given time duration."),
+ "TON": _("On-delay timer\nThe on-delay timer can be used to delay setting an output true, for fixed period after an input becomes true."),
+ "TOF": _("Off-delay timer\nThe off-delay timer can be used to delay setting an output false, for fixed period after input goes false."),
+ "RTC": _("Real time clock\nThe real time clock has many uses including time stamping, setting dates and times of day in batch reports, in alarm messages and so on."),
+ "INTEGRAL": _("Integral\nThe integral function block integrates the value of input XIN over time."),
+ "DERIVATIVE": _("Derivative\nThe derivative function block produces an output XOUT proportional to the rate of change of the input XIN."),
+ "PID": _("PID\nThe PID (proportional, Integral, Derivative) function block provides the classical three term controller for closed loop control."),
+ "RAMP": _("Ramp\nThe RAMP function block is modelled on example given in the standard."),
+ "HYSTERESIS": _("Hysteresis\nThe hysteresis function block provides a hysteresis boolean output driven by the difference of two floating point (REAL) inputs XIN1 and XIN2."),
+}
+
+for block_type in ["CTU", "CTD", "CTUD"]:
+ for return_type in ["DINT", "LINT", "UDINT", "ULINT"]:
+ StdBlockComments["%s_%s" % (block_type, return_type)] = StdBlockComments[block_type]
+
+def GetBlockInfos(pou):
+ infos = pou.getblockInfos()
+ infos["comment"] = StdBlockComments[infos["name"]]
+ infos["inputs"] = [
+ (var_name, var_type, "rising")
+ if var_name in ["CU", "CD"]
+ else (var_name, var_type, var_modifier)
+ for var_name, var_type, var_modifier in infos["inputs"]]
+ return infos
"""
Ordored list of common Function Blocks defined in the IEC 61131-3
@@ -251,99 +96,9 @@
"""
StdBlckLst = [{"name" : _("Standard function blocks"), "list":
- [{"name" : "SR", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("S1","BOOL","none"),("R","BOOL","none")],
- "outputs" : [("Q1","BOOL","none")],
- "comment" : _("SR bistable\nThe SR bistable is a latch where the Set dominates."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "RS", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("S","BOOL","none"),("R1","BOOL","none")],
- "outputs" : [("Q1","BOOL","none")],
- "comment" : _("RS bistable\nThe RS bistable is a latch where the Reset dominates."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "SEMA", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("CLAIM","BOOL","none"),("RELEASE","BOOL","none")],
- "outputs" : [("BUSY","BOOL","none")],
- "comment" : _("Semaphore\nThe semaphore provides a mechanism to allow software elements mutually exclusive access to certain ressources."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "R_TRIG", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("CLK","BOOL","none")],
- "outputs" : [("Q","BOOL","none")],
- "comment" : _("Rising edge detector\nThe output produces a single pulse when a rising edge is detected."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "F_TRIG", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("CLK","BOOL","none")],
- "outputs" : [("Q","BOOL","none")],
- "comment" : _("Falling edge detector\nThe output produces a single pulse when a falling edge is detected."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "CTU", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("CU","BOOL","rising"),("R","BOOL","none"),("PV","INT","none")],
- "outputs" : [("Q","BOOL","none"),("CV","INT","none")],
- "comment" : _("Up-counter\nThe up-counter can be used to signal when a count has reached a maximum value."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "CTD", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("CD","BOOL","rising"),("LD","BOOL","none"),("PV","INT","none")],
- "outputs" : [("Q","BOOL","none"),("CV","INT","none")],
- "comment" : _("Down-counter\nThe down-counter can be used to signal when a count has reached zero, on counting down from a preset value."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "CTUD", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("CU","BOOL","rising"),("CD","BOOL","rising"),("R","BOOL","none"),("LD","BOOL","none"),("PV","INT","none")],
- "outputs" : [("QU","BOOL","none"),("QD","BOOL","none"),("CV","INT","none")],
- "comment" : _("Up-down counter\nThe up-down counter has two inputs CU and CD. It can be used to both count up on one input and down on the other."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "TP", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("IN","BOOL","none"),("PT","TIME","none")],
- "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],
- "comment" : _("Pulse timer\nThe pulse timer can be used to generate output pulses of a given time duration."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "TON", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("IN","BOOL","none"),("PT","TIME","none")],
- "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],
- "comment" : _("On-delay timer\nThe on-delay timer can be used to delay setting an output true, for fixed period after an input becomes true."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "TOF", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("IN","BOOL","none"),("PT","TIME","none")],
- "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],
- "comment" : _("Off-delay timer\nThe off-delay timer can be used to delay setting an output false, for fixed period after input goes false."),
- "generate" : generate_block, "initialise" : initialise_block},
- ]},
+ [GetBlockInfos(pou) for pou in StdBlockLibrary.getpous()]},
{"name" : _("Additional function blocks"), "list":
- [{"name" : "RTC", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("IN","BOOL","none"),("PDT","DATE_AND_TIME","none")],
- "outputs" : [("Q","BOOL","none"),("CDT","DATE_AND_TIME","none")],
- "comment" : _("Real time clock\nThe real time clock has many uses including time stamping, setting dates and times of day in batch reports, in alarm messages and so on."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "INTEGRAL", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("RUN","BOOL","none"),("R1","BOOL","none"),("XIN","REAL","none"),("X0","REAL","none"),("CYCLE","TIME","none")],
- "outputs" : [("Q","BOOL","none"),("XOUT","REAL","none")],
- "comment" : _("Integral\nThe integral function block integrates the value of input XIN over time."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "DERIVATIVE", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("RUN","BOOL","none"),("XIN","REAL","none"),("CYCLE","TIME","none")],
- "outputs" : [("XOUT","REAL","none")],
- "comment" : _("Derivative\nThe derivative function block produces an output XOUT proportional to the rate of change of the input XIN."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "PID", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("AUTO","BOOL","none"),("PV","REAL","none"),("SP","REAL","none"),("X0","REAL","none"),("KP","REAL","none"),("TR","REAL","none"),("TD","REAL","none"),("CYCLE","TIME","none")],
- "outputs" : [("XOUT","REAL","none")],
- "comment" : _("PID\nThe PID (proportional, Integral, Derivative) function block provides the classical three term controller for closed loop control."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "RAMP", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("RUN","BOOL","none"),("X0","REAL","none"),("X1","REAL","none"),("TR","TIME","none"),("CYCLE","TIME","none")],
- "outputs" : [("BUSY","BOOL","none"),("XOUT","REAL","none")],
- "comment" : _("Ramp\nThe RAMP function block is modelled on example given in the standard."),
- "generate" : generate_block, "initialise" : initialise_block},
- {"name" : "HYSTERESIS", "type" : "functionBlock", "extensible" : False,
- "inputs" : [("XIN1","REAL","none"),("XIN2","REAL","none"),("EPS","REAL","none")],
- "outputs" : [("Q","BOOL","none")],
- "comment" : _("Hysteresis\nThe hysteresis function block provides a hysteresis boolean output driven by the difference of two floating point (REAL) inputs XIN1 and XIN2."),
- "generate" : generate_block, "initialise" : initialise_block},
-## {"name" : "RATIO_MONITOR", "type" : "functionBlock", "extensible" : False,
-## "inputs" : [("PV1","REAL","none"),("PV2","REAL","none"),("RATIO","REAL","none"),("TIMON","TIME","none"),("TIMOFF","TIME","none"),("TOLERANCE","BOOL","none"),("RESET","BOOL","none"),("CYCLE","TIME","none")],
-## "outputs" : [("ALARM","BOOL","none"),("TOTAL_ERR","BOOL","none")],
-## "comment" : _("Ratio monitor\nThe ratio_monitor function block checks that one process value PV1 is always a given ratio (defined by input RATIO) of a second process value PV2."),
-## "generate" : generate_block, "initialise" : initialise_block}
- ]},
+ [GetBlockInfos(pou) for pou in AddnlBlockLibrary.getpous()]},
]
@@ -601,8 +356,6 @@
Function_decl_list = []
if Current_section:
Function_decl = dict([(champ, val) for champ, val in zip(fonctions, fields[1:]) if champ])
- Function_decl["generate"] = generate_block
- Function_decl["initialise"] = lambda x,y:[]
baseinputnumber = int(Function_decl.get("baseinputnumber",1))
Function_decl["baseinputnumber"] = baseinputnumber
for param, value in Function_decl.iteritems():
@@ -661,24 +414,23 @@
return Standard_Functions_Decl
-std_decl = get_standard_funtions(csv_file_to_table(open(os.path.join(os.path.split(__file__)[0],"iec_std.csv"))))#, True)
+std_decl = get_standard_funtions(csv_file_to_table(open(os.path.join(ScriptDirectory,"iec_std.csv"))))#, True)
StdBlckLst.extend(std_decl)
# Dictionary to speedup block type fetching by name
-StdBlckDct = {}
+StdBlckDct = OrderedDict()
for section in StdBlckLst:
for desc in section["list"]:
words = desc["comment"].split('"')
if len(words) > 1:
desc["comment"] = words[1]
- desc["usage"] = (
- "\n (" +
- str([ " " + fctdecl[1]+":"+fctdecl[0] for fctdecl in desc["inputs"]]).strip("[]").replace("'",'') +
- " ) => (" +
- str([ " " + fctdecl[1]+":"+fctdecl[0] for fctdecl in desc["outputs"]]).strip("[]").replace("'",'') +
- " )")
+ desc["usage"] = ("\n (%s) => (%s)" %
+ (", ".join(["%s:%s" % (input[1], input[0])
+ for input in desc["inputs"]]),
+ ", ".join(["%s:%s" % (output[1], output[0])
+ for output in desc["outputs"]])))
BlkLst = StdBlckDct.setdefault(desc["name"],[])
BlkLst.append((section["name"], desc))
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plcopen/variables_infos.xslt Fri Sep 27 09:32:39 2013 +0900
@@ -0,0 +1,213 @@
+<xsl:stylesheet version="1.0"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+ xmlns:ppx="http://www.plcopen.org/xml/tc6_0201"
+ xmlns:xhtml="http://www.w3.org/1999/xhtml"
+ xmlns:ns="var_infos_ns"
+ extension-element-prefixes="ns"
+ exclude-result-prefixes="ns">
+ <xsl:template match="ppx:returnType">
+ <ReturnType>
+ <Type><xsl:apply-templates/></Type>
+ <Tree><xsl:apply-templates mode="var_tree"/></Tree>
+ </ReturnType>
+ </xsl:template>
+ <xsl:template match="ppx:localVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Local'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:globalVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Global'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:externalVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'External'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:tempVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Temp'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:inputVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Input'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:outputVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'Output'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template match="ppx:inOutVars">
+ <xsl:call-template name="variables_infos">
+ <xsl:with-param name="var_class" select="'InOut'"/>
+ </xsl:call-template>
+ </xsl:template>
+ <xsl:template name="variables_infos">
+ <xsl:param name="var_class"/>
+ <xsl:variable name="var_option">
+ <xsl:choose>
+ <xsl:when test="@constant='true' or @constant='1'">
+ <xsl:text>Constant</xsl:text>
+ </xsl:when>
+ <xsl:when test="@retain='true' or @retain='1'">
+ <xsl:text>Retain</xsl:text>
+ </xsl:when>
+ <xsl:when test="@nonretain='true' or @nonretain='1'">
+ <xsl:text>Non-Retain</xsl:text>
+ </xsl:when>
+ </xsl:choose>
+ </xsl:variable>
+ <xsl:for-each select="ppx:variable">
+ <ns:add_variable>
+ <Name><xsl:value-of select="@name"/></Name>
+ <Class><xsl:value-of select="$var_class"/></Class>
+ <Type><xsl:apply-templates select="ppx:type"/></Type>
+ <Option><xsl:value-of select="$var_option"/></Option>
+ <Location><xsl:value-of select="@address"/></Location>
+ <Initial_Value><xsl:apply-templates select="ppx:initialValue"/></Initial_Value>
+ <Edit><xsl:apply-templates select="ppx:type" mode="var_edit"/></Edit>
+ <Tree><xsl:apply-templates select="ppx:type" mode="var_tree"/></Tree>
+ <Documentation>
+ <xsl:value-of select="ppx:documentation/xhtml:p/text()"/>
+ </Documentation>
+ </ns:add_variable>
+ </xsl:for-each>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:derived">
+ <xsl:value-of select="@name"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:array">
+ <array>
+ <xsl:apply-templates select="ppx:baseType"/>
+ <xsl:for-each select="ppx:dimension">
+ <dimension>
+ <xsl:attribute name="lower">
+ <xsl:value-of select="@lower"/>
+ </xsl:attribute>
+ <xsl:attribute name="upper">
+ <xsl:value-of select="@upper"/>
+ </xsl:attribute>
+ </dimension>
+ </xsl:for-each>
+ </array>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:string">
+ <xsl:text>STRING</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:wstring">
+ <xsl:text>WSTRING</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/*">
+ <xsl:value-of select="local-name()"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:derived" mode="var_edit">
+ <ns:is_edited/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/*" mode="var_edit">
+ <xsl:text>True</xsl:text>
+ </xsl:template>
+ <xsl:template match="ppx:initialValue">
+ <xsl:apply-templates/>
+ </xsl:template>
+ <xsl:template match="ppx:value">
+ <xsl:choose>
+ <xsl:when test="@repetitionValue">
+ <xsl:value-of select="@repetitionValue"/>
+ <xsl:text>(</xsl:text>
+ <xsl:apply-templates/>
+ <xsl:text>)</xsl:text>
+ </xsl:when>
+ <xsl:when test="@member">
+ <xsl:value-of select="@member"/>
+ <xsl:text> := </xsl:text>
+ <xsl:apply-templates/>
+ </xsl:when>
+ <xsl:otherwise>
+ <xsl:apply-templates/>
+ </xsl:otherwise>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template match="ppx:simpleValue">
+ <xsl:value-of select="@value"/>
+ </xsl:template>
+ <xsl:template match="ppx:arrayValue">
+ <xsl:text>[</xsl:text>
+ <xsl:for-each select="ppx:value">
+ <xsl:apply-templates select="."/>
+ <xsl:choose>
+ <xsl:when test="position()!=last()">
+ <xsl:text>, </xsl:text>
+ </xsl:when>
+ </xsl:choose>
+ </xsl:for-each>
+ <xsl:text>]</xsl:text>
+ </xsl:template>
+ <xsl:template match="ppx:structValue">
+ <xsl:text>(</xsl:text>
+ <xsl:for-each select="ppx:value">
+ <xsl:apply-templates select="."/>
+ <xsl:choose>
+ <xsl:when test="position()!=last()">
+ <xsl:text>, </xsl:text>
+ </xsl:when>
+ </xsl:choose>
+ </xsl:for-each>
+ <xsl:text>)</xsl:text>
+ </xsl:template>
+ <xsl:template match="ppx:pou" mode="var_tree">
+ <xsl:apply-templates select="ppx:interface/*[self::ppx:inputVars or self::ppx:inOutVars or self::ppx:outputVars]/ppx:variable" mode="var_tree"/>
+ </xsl:template>
+ <xsl:template match="ppx:variable" mode="var_tree">
+ <var>
+ <xsl:attribute name="name">
+ <xsl:value-of select="@name"/>
+ </xsl:attribute>
+ <xsl:apply-templates select="ppx:type" mode="var_tree"/>
+ </var>
+ </xsl:template>
+ <xsl:template match="ppx:dataType">
+ <xsl:apply-templates select="ppx:baseType" mode="var_tree"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:struct" mode="var_tree">
+ <xsl:apply-templates select="ppx:variable" mode="var_tree"/>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:derived" mode="var_tree">
+ <ns:var_tree/>
+ <xsl:choose>
+ <xsl:when test="count(./*) > 0">
+ <xsl:apply-templates mode="var_tree"/>
+ </xsl:when>
+ <xsl:otherwise>
+ <xsl:value-of select="@name"/>
+ </xsl:otherwise>
+ </xsl:choose>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:array" mode="var_tree">
+ <xsl:apply-templates select="ppx:baseType" mode="var_tree"/>
+ <xsl:for-each select="ppx:dimension">
+ <dimension>
+ <xsl:attribute name="lower">
+ <xsl:value-of select="@lower"/>
+ </xsl:attribute>
+ <xsl:attribute name="upper">
+ <xsl:value-of select="@upper"/>
+ </xsl:attribute>
+ </dimension>
+ </xsl:for-each>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:string" mode="var_tree">
+ <xsl:text>STRING</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/ppx:wstring" mode="var_tree">
+ <xsl:text>WSTRING</xsl:text>
+ </xsl:template>
+ <xsl:template match="*[self::ppx:type or self::ppx:baseType or self::ppx:returnType]/*" mode="var_tree">
+ <xsl:value-of select="local-name()"/>
+ </xsl:template>
+ <xsl:template match="text()"/>
+ <xsl:template match="text()" mode="var_tree"/>
+</xsl:stylesheet>
\ No newline at end of file
--- a/py_ext/PythonFileCTNMixin.py Thu Sep 26 20:47:36 2013 +0900
+++ b/py_ext/PythonFileCTNMixin.py Fri Sep 27 09:32:39 2013 +0900
@@ -1,15 +1,11 @@
-import os
-from PLCControler import UndoBuffer
+import os, re
+from lxml import etree
+
+from xmlclass import GenerateParserFromXSD
+
+from CodeFileTreeNode import CodeFile
from PythonEditor import PythonEditor
-from xml.dom import minidom
-from xmlclass import GenerateClassesFromXSD
-import cPickle
-
-from CodeFileTreeNode import CodeFile
-
-PythonClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "py_ext_xsd.xsd"))
-
class PythonFileCTNMixin(CodeFile):
CODEFILE_NAME = "PyFile"
@@ -26,19 +22,27 @@
filepath = self.PythonFileName()
- python_code = PythonClasses["Python"]()
if os.path.isfile(filepath):
+ PythonParser = GenerateParserFromXSD(
+ os.path.join(os.path.dirname(__file__), "py_ext_xsd.xsd"))
+
xmlfile = open(filepath, 'r')
- tree = minidom.parse(xmlfile)
+ pythonfile_xml = xmlfile.read()
xmlfile.close()
- for child in tree.childNodes:
- if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "Python":
- python_code.loadXMLTree(child, ["xmlns", "xmlns:xsi", "xsi:schemaLocation"])
- self.CodeFile.globals.settext(python_code.gettext())
- os.remove(filepath)
- self.CreateCodeFileBuffer(False)
- self.OnCTNSave()
+ pythonfile_xml = pythonfile_xml.replace(
+ 'xmlns="http://www.w3.org/2001/XMLSchema"',
+ 'xmlns:xhtml="http://www.w3.org/1999/xhtml"')
+ for cre, repl in [
+ (re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),
+ (re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:
+ pythonfile_xml = cre.sub(repl, pythonfile_xml)
+ python_code = etree.fromstring(pythonfile_xml, PythonParser)
+
+ self.CodeFile.globals.setanyText(python_code.getanyText())
+ os.remove(filepath)
+ self.CreateCodeFileBuffer(False)
+ self.OnCTNSave()
def CodeFileName(self):
return os.path.join(self.CTNPath(), "pyfile.xml")
@@ -50,7 +54,7 @@
PostSectionsTexts = {}
def GetSection(self,section):
return self.PreSectionsTexts.get(section,"") + "\n" + \
- getattr(self.CodeFile, section).gettext() + "\n" + \
+ getattr(self.CodeFile, section).getanyText() + "\n" + \
self.PostSectionsTexts.get(section,"")
--- a/py_ext/py_ext_xsd.xsd Thu Sep 26 20:47:36 2013 +0900
+++ b/py_ext/py_ext_xsd.xsd Fri Sep 27 09:32:39 2013 +0900
@@ -1,18 +1,14 @@
<?xml version="1.0" encoding="ISO-8859-1" ?>
-<xsd:schema targetNamespace="python_xsd.xsd"
- xmlns:cext="python_xsd.xsd"
- xmlns:xsd="http://www.w3.org/2001/XMLSchema"
- elementFormDefault="qualified"
- attributeFormDefault="unqualified">
-
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+ xmlns:xhtml="http://www.w3.org/1999/xhtml">
<xsd:element name="Python">
- <xsd:complexType>
- <xsd:annotation>
- <xsd:documentation>Formatted text according to parts of XHTML 1.1</xsd:documentation>
- </xsd:annotation>
- <xsd:sequence>
- <xsd:any namespace="http://www.w3.org/1999/xhtml" processContents="lax"/>
- </xsd:sequence>
- </xsd:complexType>
- </xsd:element>
+ <xsd:complexType>
+ <xsd:annotation>
+ <xsd:documentation>Formatted text according to parts of XHTML 1.1</xsd:documentation>
+ </xsd:annotation>
+ <xsd:sequence>
+ <xsd:any namespace="http://www.w3.org/1999/xhtml" processContents="lax"/>
+ </xsd:sequence>
+ </xsd:complexType>
+ </xsd:element>
</xsd:schema>
--- a/targets/Xenomai/__init__.py Thu Sep 26 20:47:36 2013 +0900
+++ b/targets/Xenomai/__init__.py Fri Sep 27 09:32:39 2013 +0900
@@ -5,7 +5,7 @@
extension = ".so"
def getXenoConfig(self, flagsname):
""" Get xeno-config from target parameters """
- xeno_config=self.CTRInstance.GetTarget().getcontent()["value"].getXenoConfig()
+ xeno_config=self.CTRInstance.GetTarget().getcontent().getXenoConfig()
if xeno_config:
from util.ProcessLogger import ProcessLogger
status, result, err_result = ProcessLogger(self.CTRInstance.logger,
--- a/targets/toolchain_gcc.py Thu Sep 26 20:47:36 2013 +0900
+++ b/targets/toolchain_gcc.py Fri Sep 27 09:32:39 2013 +0900
@@ -19,14 +19,14 @@
"""
Returns list of builder specific CFLAGS
"""
- return [self.CTRInstance.GetTarget().getcontent()["value"].getCFLAGS()]
+ return [self.CTRInstance.GetTarget().getcontent().getCFLAGS()]
def getBuilderLDFLAGS(self):
"""
Returns list of builder specific LDFLAGS
"""
return self.CTRInstance.LDFLAGS + \
- [self.CTRInstance.GetTarget().getcontent()["value"].getLDFLAGS()]
+ [self.CTRInstance.GetTarget().getcontent().getLDFLAGS()]
def GetBinaryCode(self):
try:
@@ -89,7 +89,7 @@
def build(self):
# Retrieve toolchain user parameters
- toolchain_params = self.CTRInstance.GetTarget().getcontent()["value"]
+ toolchain_params = self.CTRInstance.GetTarget().getcontent()
self.compiler = toolchain_params.getCompiler()
self.linker = toolchain_params.getLinker()
--- a/xmlclass/__init__.py Thu Sep 26 20:47:36 2013 +0900
+++ b/xmlclass/__init__.py Fri Sep 27 09:32:39 2013 +0900
@@ -24,5 +24,5 @@
# Package initialisation
-from xmlclass import ClassFactory, GenerateClasses, GetAttributeValue, time_model, CreateNode, NodeSetAttr, NodeRenameAttr, UpdateXMLClassGlobals
-from xsdschema import XSDClassFactory, GenerateClassesFromXSD, GenerateClassesFromXSDstring
+from xmlclass import ClassFactory, GenerateParser, DefaultElementClass, GetAttributeValue, time_model, CreateNode, NodeSetAttr, NodeRenameAttr
+from xsdschema import XSDClassFactory, GenerateParserFromXSD, GenerateParserFromXSDstring
--- a/xmlclass/xmlclass.py Thu Sep 26 20:47:36 2013 +0900
+++ b/xmlclass/xmlclass.py Fri Sep 27 09:32:39 2013 +0900
@@ -28,7 +28,9 @@
from types import *
from xml.dom import minidom
from xml.sax.saxutils import escape, unescape, quoteattr
+from lxml import etree
from new import classobj
+from collections import OrderedDict
def CreateNode(name):
node = minidom.Node()
@@ -533,28 +535,33 @@
return GetModelNameList
def GenerateAnyInfos(infos):
+
+ def GetTextElement(tree):
+ if infos["namespace"][0] == "##any":
+ return tree.xpath("p")[0]
+ return tree.xpath("ns:p", namespaces={"ns": infos["namespace"][0]})[0]
+
def ExtractAny(tree):
- if tree.nodeName in ["#text", "#cdata-section"]:
- return unicode(unescape(tree.data))
- else:
- return tree
-
- def GenerateAny(value, name=None, indent=0):
- if isinstance(value, (StringType, UnicodeType)):
- try:
- value = value.decode("utf-8")
- except:
- pass
- return u'<![CDATA[%s]]>\n' % value
- else:
- return value.toprettyxml(indent=" "*indent, encoding="utf-8")
+ return GetTextElement(tree).text
+
+ def GenerateAny(tree, value):
+ GetTextElement(tree).text = etree.CDATA(value)
+
+ def InitialAny():
+ if infos["namespace"][0] == "##any":
+ element_name = "p"
+ else:
+ element_name = "{%s}p" % infos["namespace"][0]
+ p = etree.Element(element_name)
+ p.text = etree.CDATA("")
+ return p
return {
"type": COMPLEXTYPE,
"extract": ExtractAny,
"generate": GenerateAny,
- "initial": lambda: "",
- "check": lambda x: isinstance(x, (StringType, UnicodeType, minidom.Node))
+ "initial": InitialAny,
+ "check": lambda x: isinstance(x, (StringType, UnicodeType, etree.ElementBase))
}
def GenerateTagInfos(infos):
@@ -591,38 +598,23 @@
def GetElementInitialValue(factory, infos):
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if infos["minOccurs"] == 0 and infos["maxOccurs"] == 1:
- if infos.has_key("default"):
- return infos["elmt_type"]["extract"](infos["default"], False)
- else:
- return None
- elif infos["minOccurs"] == 1 and infos["maxOccurs"] == 1:
- return infos["elmt_type"]["initial"]()
+ if infos["minOccurs"] == 1:
+ element_name = factory.etreeNamespaceFormat % infos["name"]
+ if infos["elmt_type"]["type"] == SIMPLETYPE:
+ def initial_value():
+ value = etree.Element(element_name)
+ value.text = (infos["elmt_type"]["generate"](infos["elmt_type"]["initial"]()))
+ return value
+ else:
+ def initial_value():
+ value = infos["elmt_type"]["initial"]()
+ if infos["type"] != ANY:
+ DefaultElementClass.__setattr__(value, "tag", element_name)
+ value._init_()
+ return value
+ return [initial_value() for i in xrange(infos["minOccurs"])]
else:
- return [infos["elmt_type"]["initial"]() for i in xrange(infos["minOccurs"])]
-
-def HandleError(message, raise_exception):
- if raise_exception:
- raise ValueError(message)
- return False
-
-def CheckElementValue(factory, name, infos, value, raise_exception=True):
- infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if value is None and raise_exception:
- if not (infos["minOccurs"] == 0 and infos["maxOccurs"] == 1):
- return HandleError("Attribute '%s' isn't optional." % name, raise_exception)
- elif infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:
- if not isinstance(value, ListType):
- return HandleError("Attribute '%s' must be a list." % name, raise_exception)
- if len(value) < infos["minOccurs"] or infos["maxOccurs"] != "unbounded" and len(value) > infos["maxOccurs"]:
- return HandleError("List out of bounds for attribute '%s'." % name, raise_exception)
- if not reduce(lambda x, y: x and y, map(infos["elmt_type"]["check"], value), True):
- return HandleError("Attribute '%s' must be a list of valid elements." % name, raise_exception)
- elif infos.has_key("fixed") and value != infos["fixed"]:
- return HandleError("Value of attribute '%s' can only be '%s'." % (name, str(infos["fixed"])), raise_exception)
- else:
- return infos["elmt_type"]["check"](value)
- return True
+ return []
def GetContentInfos(name, choices):
for choice_infos in choices:
@@ -649,6 +641,7 @@
sequence_element["elmt_type"] = element_infos
elif choice["elmt_type"] == "tag":
choice["elmt_type"] = GenerateTagInfos(choice)
+ factory.AddToLookupClass(choice["name"], name, DefaultElementClass)
else:
choice_infos = factory.ExtractTypeInfos(choice["name"], name, choice["elmt_type"])
if choice_infos is not None:
@@ -656,26 +649,6 @@
choices.append((choice["name"], choice))
return choices
-def ExtractContentElement(factory, tree, infos, content):
- infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:
- if isinstance(content, ListType) and len(content) > 0 and \
- content[-1]["name"] == tree.nodeName:
- content_item = content.pop(-1)
- content_item["value"].append(infos["elmt_type"]["extract"](tree))
- return content_item
- elif not isinstance(content, ListType) and \
- content is not None and \
- content["name"] == tree.nodeName:
- return {"name": tree.nodeName,
- "value": content["value"] + [infos["elmt_type"]["extract"](tree)]}
- else:
- return {"name": tree.nodeName,
- "value": [infos["elmt_type"]["extract"](tree)]}
- else:
- return {"name": tree.nodeName,
- "value": infos["elmt_type"]["extract"](tree)}
-
def GenerateContentInfos(factory, name, choices):
choices_dict = {}
for choice_name, infos in choices:
@@ -691,6 +664,9 @@
if choices_dict.has_key(choice_name):
raise ValueError("'%s' element defined two times in choice" % choice_name)
choices_dict[choice_name] = infos
+ prefix = ("%s:" % factory.TargetNamespace
+ if factory.TargetNamespace is not None else "")
+ choices_xpath = "|".join(map(lambda x: prefix + x, choices_dict.keys()))
def GetContentInitial():
content_name, infos = choices[0]
@@ -698,140 +674,15 @@
content_value = []
for i in xrange(infos["minOccurs"]):
for element_infos in infos["elements"]:
- value = GetElementInitialValue(factory, element_infos)
- if value is not None:
- if element_infos["type"] == CHOICE:
- content_value.append(value)
- else:
- content_value.append({"name": element_infos["name"], "value": value})
+ content_value.extend(GetElementInitialValue(factory, element_infos))
else:
content_value = GetElementInitialValue(factory, infos)
- return {"name": content_name, "value": content_value}
-
- def CheckContent(value):
- if value["name"] != "sequence":
- infos = choices_dict.get(value["name"], None)
- if infos is not None:
- return CheckElementValue(factory, value["name"], infos, value["value"], False)
- elif len(value["value"]) > 0:
- infos = choices_dict.get(value["value"][0]["name"], None)
- if infos is None:
- for choice_name, infos in choices:
- if infos["type"] == "sequence":
- for element_infos in infos["elements"]:
- if element_infos["type"] == CHOICE:
- infos = GetContentInfos(value["value"][0]["name"], element_infos["choices"])
- if infos is not None:
- sequence_number = 0
- element_idx = 0
- while element_idx < len(value["value"]):
- for element_infos in infos["elements"]:
- element_value = None
- if element_infos["type"] == CHOICE:
- choice_infos = None
- if element_idx < len(value["value"]):
- for choice in element_infos["choices"]:
- if choice["name"] == value["value"][element_idx]["name"]:
- choice_infos = choice
- element_value = value["value"][element_idx]["value"]
- element_idx += 1
- break
- if ((choice_infos is not None and
- not CheckElementValue(factory, choice_infos["name"], choice_infos, element_value, False)) or
- (choice_infos is None and element_infos["minOccurs"] > 0)):
- raise ValueError("Invalid sequence value in attribute 'content'")
- else:
- if element_idx < len(value["value"]) and element_infos["name"] == value["value"][element_idx]["name"]:
- element_value = value["value"][element_idx]["value"]
- element_idx += 1
- if not CheckElementValue(factory, element_infos["name"], element_infos, element_value, False):
- raise ValueError("Invalid sequence value in attribute 'content'")
- sequence_number += 1
- if sequence_number < infos["minOccurs"] or infos["maxOccurs"] != "unbounded" and sequence_number > infos["maxOccurs"]:
- raise ValueError("Invalid sequence value in attribute 'content'")
- return True
- else:
- for element_name, infos in choices:
- if element_name == "sequence":
- required = 0
- for element in infos["elements"]:
- if element["minOccurs"] > 0:
- required += 1
- if required == 0:
- return True
- return False
-
- def ExtractContent(tree, content):
- infos = choices_dict.get(tree.nodeName, None)
- if infos is not None:
- if infos["name"] == "sequence":
- sequence_dict = dict([(element_infos["name"], element_infos) for element_infos in infos["elements"] if element_infos["type"] != CHOICE])
- element_infos = sequence_dict.get(tree.nodeName)
- if content is not None and \
- content["name"] == "sequence" and \
- len(content["value"]) > 0 and \
- choices_dict.get(content["value"][-1]["name"]) == infos:
- return {"name": "sequence",
- "value": content["value"] + [ExtractContentElement(factory, tree, element_infos, content["value"][-1])]}
- else:
- return {"name": "sequence",
- "value": [ExtractContentElement(factory, tree, element_infos, None)]}
- else:
- return ExtractContentElement(factory, tree, infos, content)
- else:
- for choice_name, infos in choices:
- if infos["type"] == "sequence":
- for element_infos in infos["elements"]:
- if element_infos["type"] == CHOICE:
- try:
- if content is not None and \
- content["name"] == "sequence" and \
- len(content["value"]) > 0:
- return {"name": "sequence",
- "value": content["value"] + [element_infos["elmt_type"]["extract"](tree, content["value"][-1])]}
- else:
- return {"name": "sequence",
- "value": [element_infos["elmt_type"]["extract"](tree, None)]}
- except:
- pass
- raise ValueError("Invalid element \"%s\" for content!" % tree.nodeName)
-
- def GenerateContent(value, name=None, indent=0):
- text = ""
- if value["name"] != "sequence":
- infos = choices_dict.get(value["name"], None)
- if infos is not None:
- infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:
- for item in value["value"]:
- text += infos["elmt_type"]["generate"](item, value["name"], indent)
- else:
- text += infos["elmt_type"]["generate"](value["value"], value["name"], indent)
- elif len(value["value"]) > 0:
- infos = choices_dict.get(value["value"][0]["name"], None)
- if infos is None:
- for choice_name, infos in choices:
- if infos["type"] == "sequence":
- for element_infos in infos["elements"]:
- if element_infos["type"] == CHOICE:
- infos = GetContentInfos(value["value"][0]["name"], element_infos["choices"])
- if infos is not None:
- sequence_dict = dict([(element_infos["name"], element_infos) for element_infos in infos["elements"]])
- for element_value in value["value"]:
- element_infos = sequence_dict.get(element_value["name"])
- if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
- for item in element_value["value"]:
- text += element_infos["elmt_type"]["generate"](item, element_value["name"], indent)
- else:
- text += element_infos["elmt_type"]["generate"](element_value["value"], element_infos["name"], indent)
- return text
+ return content_value
return {
"type": COMPLEXTYPE,
+ "choices_xpath": etree.XPath(choices_xpath, namespaces=factory.NSMAP),
"initial": GetContentInitial,
- "check": CheckContent,
- "extract": ExtractContent,
- "generate": GenerateContent
}
#-------------------------------------------------------------------------------
@@ -901,9 +752,11 @@
self.XMLClassDefinitions = {}
self.DefinedNamespaces = {}
+ self.NSMAP = {}
self.Namespaces = {}
self.SchemaNamespace = None
self.TargetNamespace = None
+ self.etreeNamespaceFormat = "%s"
self.CurrentCompilations = []
@@ -914,6 +767,8 @@
else:
self.ComputedClasses = {}
self.ComputedClassesInfos = {}
+ self.ComputedClassesLookUp = {}
+ self.EquivalentClassesParent = {}
self.AlreadyComputed = {}
def GetQualifiedNameInfos(self, name, namespace=None, canbenone=False):
@@ -1016,7 +871,9 @@
attrs[name] = infos["extract"]["default"](attr)
elif namespace == "xmlns":
infos = self.GetQualifiedNameInfos("anyURI", self.SchemaNamespace)
- self.DefinedNamespaces[infos["extract"](attr)] = name
+ value = infos["extract"](attr)
+ self.DefinedNamespaces[value] = name
+ self.NSMAP[name] = value
else:
raise ValueError("Invalid attribute \"%s\" for member \"%s\"!" % (qualified_name, node.nodeName))
for attr in valid_attrs:
@@ -1063,20 +920,63 @@
def ParseSchema(self):
pass
-
+
+ def AddEquivalentClass(self, name, base):
+ if name != base:
+ equivalences = self.EquivalentClassesParent.setdefault(self.etreeNamespaceFormat % base, {})
+ equivalences[self.etreeNamespaceFormat % name] = True
+
+ def AddDistinctionBetweenParentsInLookupClass(
+ self, lookup_classes, parent, typeinfos):
+ parent = (self.etreeNamespaceFormat % parent
+ if parent is not None else None)
+ parent_class = lookup_classes.get(parent)
+ if parent_class is not None:
+ if isinstance(parent_class, ListType):
+ if typeinfos not in parent_class:
+ lookup_classes[parent].append(typeinfos)
+ elif parent_class != typeinfos:
+ lookup_classes[parent] = [parent_class, typeinfos]
+ else:
+ lookup_classes[parent] = typeinfos
+
+ def AddToLookupClass(self, name, parent, typeinfos):
+ lookup_name = self.etreeNamespaceFormat % name
+ if isinstance(typeinfos, (StringType, UnicodeType)):
+ self.AddEquivalentClass(name, typeinfos)
+ typeinfos = self.etreeNamespaceFormat % typeinfos
+ lookup_classes = self.ComputedClassesLookUp.get(lookup_name)
+ if lookup_classes is None:
+ self.ComputedClassesLookUp[lookup_name] = (typeinfos, parent)
+ elif isinstance(lookup_classes, DictType):
+ self.AddDistinctionBetweenParentsInLookupClass(
+ lookup_classes, parent, typeinfos)
+ else:
+ lookup_classes = {
+ self.etreeNamespaceFormat % lookup_classes[1]
+ if lookup_classes[1] is not None else None: lookup_classes[0]}
+ self.AddDistinctionBetweenParentsInLookupClass(
+ lookup_classes, parent, typeinfos)
+ self.ComputedClassesLookUp[lookup_name] = lookup_classes
+
def ExtractTypeInfos(self, name, parent, typeinfos):
if isinstance(typeinfos, (StringType, UnicodeType)):
- namespace, name = DecomposeQualifiedName(typeinfos)
- infos = self.GetQualifiedNameInfos(name, namespace)
+ namespace, type_name = DecomposeQualifiedName(typeinfos)
+ infos = self.GetQualifiedNameInfos(type_name, namespace)
+ if name != "base":
+ if infos["type"] == SIMPLETYPE:
+ self.AddToLookupClass(name, parent, DefaultElementClass)
+ elif namespace == self.TargetNamespace:
+ self.AddToLookupClass(name, parent, type_name)
if infos["type"] == COMPLEXTYPE:
- name, parent = self.SplitQualifiedName(name, namespace)
- result = self.CreateClass(name, parent, infos)
+ type_name, parent = self.SplitQualifiedName(type_name, namespace)
+ result = self.CreateClass(type_name, parent, infos)
if result is not None and not isinstance(result, (UnicodeType, StringType)):
self.Namespaces[self.TargetNamespace][result["name"]] = result
return result
elif infos["type"] == ELEMENT and infos["elmt_type"]["type"] == COMPLEXTYPE:
- name, parent = self.SplitQualifiedName(name, namespace)
- result = self.CreateClass(name, parent, infos["elmt_type"])
+ type_name, parent = self.SplitQualifiedName(type_name, namespace)
+ result = self.CreateClass(type_name, parent, infos["elmt_type"])
if result is not None and not isinstance(result, (UnicodeType, StringType)):
self.Namespaces[self.TargetNamespace][result["name"]] = result
return result
@@ -1086,7 +986,12 @@
return self.CreateClass(name, parent, typeinfos)
elif typeinfos["type"] == SIMPLETYPE:
return typeinfos
-
+
+ def GetEquivalentParents(self, parent):
+ return reduce(lambda x, y: x + y,
+ [[p] + self.GetEquivalentParents(p)
+ for p in self.EquivalentClassesParent.get(parent, {}).keys()], [])
+
"""
Methods that generates the classes
"""
@@ -1123,6 +1028,21 @@
if result is not None and \
not isinstance(result, (UnicodeType, StringType)):
self.Namespaces[self.TargetNamespace][result["name"]] = result
+
+ for name, parents in self.ComputedClassesLookUp.iteritems():
+ if isinstance(parents, DictType):
+ computed_classes = parents.items()
+ elif parents[1] is not None:
+ computed_classes = [(self.etreeNamespaceFormat % parents[1], parents[0])]
+ else:
+ computed_classes = []
+ for parent, computed_class in computed_classes:
+ for equivalent_parent in self.GetEquivalentParents(parent):
+ if not isinstance(parents, DictType):
+ parents = dict(computed_classes)
+ self.ComputedClassesLookUp[name] = parents
+ parents[equivalent_parent] = computed_class
+
return self.ComputedClasses
def CreateClass(self, name, parent, classinfos, baseclass = False):
@@ -1141,9 +1061,12 @@
bases = []
base_infos = classinfos.get("base", None)
if base_infos is not None:
+ namespace, base_name = DecomposeQualifiedName(base_infos)
+ if namespace == self.TargetNamespace:
+ self.AddEquivalentClass(name, base_name)
result = self.ExtractTypeInfos("base", name, base_infos)
if result is None:
- namespace, base_name = DecomposeQualifiedName(base_infos)
+ namespace, base_name = DecomposeQualifiedName(base_infos)
if self.AlreadyComputed.get(base_name, False):
self.ComputeAfter.append((name, parent, classinfos))
if self.TargetNamespace is not None:
@@ -1164,7 +1087,7 @@
if classinfos["base"] is None:
raise ValueError("No class found for base type")
bases.append(classinfos["base"])
- bases.append(object)
+ bases.append(DefaultElementClass)
bases = tuple(bases)
classmembers = {"__doc__": classinfos.get("doc", ""), "IsBaseClass": baseclass}
@@ -1177,11 +1100,8 @@
raise ValueError("\"%s\" type is not a simple type!" % attribute["attr_type"])
attrname = attribute["name"]
if attribute["use"] == "optional":
- classmembers[attrname] = None
classmembers["add%s"%attrname] = generateAddMethod(attrname, self, attribute)
classmembers["delete%s"%attrname] = generateDeleteMethod(attrname)
- else:
- classmembers[attrname] = infos["initial"]()
classmembers["set%s"%attrname] = generateSetMethod(attrname)
classmembers["get%s"%attrname] = generateGetMethod(attrname)
else:
@@ -1200,54 +1120,43 @@
classmembers["set%sbytype" % elmtname] = generateSetChoiceByTypeMethod(self, element["choices"])
infos = GenerateContentInfos(self, name, choices)
elif element["type"] == ANY:
- elmtname = element["name"] = "text"
+ elmtname = element["name"] = "anyText"
element["minOccurs"] = element["maxOccurs"] = 1
infos = GenerateAnyInfos(element)
else:
elmtname = element["name"]
if element["elmt_type"] == "tag":
infos = GenerateTagInfos(element)
+ self.AddToLookupClass(element["name"], name, DefaultElementClass)
else:
infos = self.ExtractTypeInfos(element["name"], name, element["elmt_type"])
if infos is not None:
element["elmt_type"] = infos
if element["maxOccurs"] == "unbounded" or element["maxOccurs"] > 1:
- classmembers[elmtname] = []
classmembers["append%s" % elmtname] = generateAppendMethod(elmtname, element["maxOccurs"], self, element)
classmembers["insert%s" % elmtname] = generateInsertMethod(elmtname, element["maxOccurs"], self, element)
classmembers["remove%s" % elmtname] = generateRemoveMethod(elmtname, element["minOccurs"])
classmembers["count%s" % elmtname] = generateCountMethod(elmtname)
else:
if element["minOccurs"] == 0:
- classmembers[elmtname] = None
classmembers["add%s" % elmtname] = generateAddMethod(elmtname, self, element)
classmembers["delete%s" % elmtname] = generateDeleteMethod(elmtname)
- elif not isinstance(element["elmt_type"], (UnicodeType, StringType)):
- classmembers[elmtname] = element["elmt_type"]["initial"]()
- else:
- classmembers[elmtname] = None
classmembers["set%s" % elmtname] = generateSetMethod(elmtname)
classmembers["get%s" % elmtname] = generateGetMethod(elmtname)
- classmembers["__init__"] = generateInitMethod(self, classinfos)
- classmembers["getStructure"] = generateStructureMethod(classinfos)
- classmembers["loadXMLTree"] = generateLoadXMLTree(self, classinfos)
- classmembers["generateXMLText"] = generateGenerateXMLText(self, classinfos)
+ classmembers["_init_"] = generateInitMethod(self, classinfos)
+ classmembers["StructurePattern"] = GetStructurePattern(classinfos)
classmembers["getElementAttributes"] = generateGetElementAttributes(self, classinfos)
classmembers["getElementInfos"] = generateGetElementInfos(self, classinfos)
classmembers["setElementValue"] = generateSetElementValue(self, classinfos)
- classmembers["singleLineAttributes"] = True
- classmembers["compatibility"] = lambda x, y: None
- classmembers["extraAttrs"] = {}
class_definition = classobj(str(classname), bases, classmembers)
+ setattr(class_definition, "__getattr__", generateGetattrMethod(self, class_definition, classinfos))
setattr(class_definition, "__setattr__", generateSetattrMethod(self, class_definition, classinfos))
class_infos = {"type": COMPILEDCOMPLEXTYPE,
"name": classname,
- "check": generateClassCheckFunction(class_definition),
"initial": generateClassCreateFunction(class_definition),
- "extract": generateClassExtractFunction(class_definition),
- "generate": class_definition.generateXMLText}
+ }
if self.FileName is not None:
self.ComputedClasses[self.FileName][classname] = class_definition
@@ -1255,6 +1164,9 @@
self.ComputedClasses[classname] = class_definition
self.ComputedClassesInfos[classname] = class_infos
+ self.AddToLookupClass(name, parent, class_definition)
+ self.AddToLookupClass(classname, None, class_definition)
+
return class_infos
"""
@@ -1281,69 +1193,6 @@
print classname
"""
-Method that generate the method for checking a class instance
-"""
-def generateClassCheckFunction(class_definition):
- def classCheckfunction(instance):
- return isinstance(instance, class_definition)
- return classCheckfunction
-
-"""
-Method that generate the method for creating a class instance
-"""
-def generateClassCreateFunction(class_definition):
- def classCreatefunction():
- return class_definition()
- return classCreatefunction
-
-"""
-Method that generate the method for extracting a class instance
-"""
-def generateClassExtractFunction(class_definition):
- def classExtractfunction(node):
- instance = class_definition()
- instance.loadXMLTree(node)
- return instance
- return classExtractfunction
-
-"""
-Method that generate the method for loading an xml tree by following the
-attributes list defined
-"""
-def generateSetattrMethod(factory, class_definition, classinfos):
- attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
- optional_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "optional"])
- elements = dict([(element["name"], element) for element in classinfos["elements"]])
-
- def setattrMethod(self, name, value):
- if attributes.has_key(name):
- attributes[name]["attr_type"] = FindTypeInfos(factory, attributes[name]["attr_type"])
- if value is None:
- if optional_attributes.get(name, False):
- return object.__setattr__(self, name, None)
- else:
- raise ValueError("Attribute '%s' isn't optional." % name)
- elif attributes[name].has_key("fixed") and value != attributes[name]["fixed"]:
- raise ValueError, "Value of attribute '%s' can only be '%s'."%(name, str(attributes[name]["fixed"]))
- elif attributes[name]["attr_type"]["check"](value):
- return object.__setattr__(self, name, value)
- else:
- raise ValueError("Invalid value for attribute '%s'." % (name))
- elif elements.has_key(name):
- if CheckElementValue(factory, name, elements[name], value):
- return object.__setattr__(self, name, value)
- else:
- raise ValueError("Invalid value for attribute '%s'." % (name))
- elif classinfos.has_key("base"):
- return classinfos["base"].__setattr__(self, name, value)
- elif class_definition.__dict__.has_key(name):
- return object.__setattr__(self, name, value)
- else:
- raise AttributeError("'%s' can't have an attribute '%s'." % (self.__class__.__name__, name))
-
- return setattrMethod
-
-"""
Method that generate the method for generating the xml tree structure model by
following the attributes list defined
"""
@@ -1369,7 +1218,10 @@
return "(?:%s){%d,%d}" % (name, infos["minOccurs"],
infos["maxOccurs"])
-def GetStructure(classinfos):
+def GetStructurePattern(classinfos):
+ base_structure_pattern = (
+ classinfos["base"].StructurePattern.pattern[:-1]
+ if classinfos.has_key("base") else "")
elements = []
for element in classinfos["elements"]:
if element["type"] == ANY:
@@ -1380,7 +1232,7 @@
choices = []
for infos in element["choices"]:
if infos["type"] == "sequence":
- structure = "(?:%s)" % GetStructure(infos)
+ structure = "(?:%s)" % GetStructurePattern(infos)
else:
structure = "%s " % infos["name"]
choices.append(ComputeMultiplicity(structure, infos))
@@ -1390,170 +1242,139 @@
else:
elements.append(ComputeMultiplicity("%s " % element["name"], element))
if classinfos.get("order", True) or len(elements) == 0:
- return "".join(elements)
+ return re.compile(base_structure_pattern + "".join(elements) + "$")
else:
raise ValueError("XSD structure not yet supported!")
-def generateStructureMethod(classinfos):
- def getStructureMethod(self):
- structure = GetStructure(classinfos)
- if classinfos.has_key("base"):
- return classinfos["base"].getStructure(self) + structure
- return structure
- return getStructureMethod
-
"""
-Method that generate the method for loading an xml tree by following the
-attributes list defined
+Method that generate the method for creating a class instance
"""
-def generateLoadXMLTree(factory, classinfos):
+def generateClassCreateFunction(class_definition):
+ def classCreatefunction():
+ return class_definition()
+ return classCreatefunction
+
+def generateGetattrMethod(factory, class_definition, classinfos):
attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
+ optional_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "optional"])
elements = dict([(element["name"], element) for element in classinfos["elements"]])
- def loadXMLTreeMethod(self, tree, extras=[], derived=False):
- self.extraAttrs = {}
- self.compatibility(tree)
- if not derived:
- children_structure = ""
- for node in tree.childNodes:
- if not (node.nodeName == "#text" and node.data.strip() == "") and node.nodeName != "#comment":
- children_structure += "%s " % node.nodeName
- structure_pattern = self.getStructure()
- if structure_pattern != "":
- structure_model = re.compile("(%s)$" % structure_pattern)
- result = structure_model.match(children_structure)
- if not result:
- raise ValueError("Invalid structure for \"%s\" children!." % tree.nodeName)
- required_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "required"])
- if classinfos.has_key("base"):
- extras.extend([attr["name"] for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
- classinfos["base"].loadXMLTree(self, tree, extras, True)
- for attrname, attr in tree._attrs.iteritems():
- if attributes.has_key(attrname):
- attributes[attrname]["attr_type"] = FindTypeInfos(factory, attributes[attrname]["attr_type"])
- object.__setattr__(self, attrname, attributes[attrname]["attr_type"]["extract"](attr))
- elif not classinfos.has_key("base") and not attrname in extras and not self.extraAttrs.has_key(attrname):
- self.extraAttrs[attrname] = GetAttributeValue(attr)
- required_attributes.pop(attrname, None)
- if len(required_attributes) > 0:
- raise ValueError("Required attributes %s missing for \"%s\" element!" % (", ".join(["\"%s\""%name for name in required_attributes]), tree.nodeName))
- first = {}
- for node in tree.childNodes:
- name = node.nodeName
- if name == "#text" and node.data.strip() == "" or name == "#comment":
- continue
- elif elements.has_key(name):
- elements[name]["elmt_type"] = FindTypeInfos(factory, elements[name]["elmt_type"])
- if elements[name]["maxOccurs"] == "unbounded" or elements[name]["maxOccurs"] > 1:
- if first.get(name, True):
- object.__setattr__(self, name, [elements[name]["elmt_type"]["extract"](node)])
- first[name] = False
+ def getattrMethod(self, name):
+ if attributes.has_key(name):
+ attribute_infos = attributes[name]
+ attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"])
+ value = self.get(name)
+ if value is not None:
+ return attribute_infos["attr_type"]["extract"](value, extract=False)
+ elif attribute_infos.has_key("fixed"):
+ return attribute_infos["attr_type"]["extract"](attribute_infos["fixed"], extract=False)
+ elif attribute_infos.has_key("default"):
+ return attribute_infos["attr_type"]["extract"](attribute_infos["default"], extract=False)
+ return None
+
+ elif elements.has_key(name):
+ element_infos = elements[name]
+ element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])
+ if element_infos["type"] == CHOICE:
+ content = element_infos["elmt_type"]["choices_xpath"](self)
+ if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
+ return content
+ elif len(content) > 0:
+ return content[0]
+ return None
+ elif element_infos["type"] == ANY:
+ return element_infos["elmt_type"]["extract"](self)
+ elif name == "content" and element_infos["elmt_type"]["type"] == SIMPLETYPE:
+ return element_infos["elmt_type"]["extract"](self.text, extract=False)
+ else:
+ element_name = factory.etreeNamespaceFormat % name
+ if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
+ values = self.findall(element_name)
+ if element_infos["elmt_type"]["type"] == SIMPLETYPE:
+ return map(lambda value:
+ element_infos["elmt_type"]["extract"](value.text, extract=False),
+ values)
+ return values
+ else:
+ value = self.find(element_name)
+ if element_infos["elmt_type"]["type"] == SIMPLETYPE:
+ return element_infos["elmt_type"]["extract"](value.text, extract=False)
+ return value
+
+ elif classinfos.has_key("base"):
+ return classinfos["base"].__getattr__(self, name)
+
+ return DefaultElementClass.__getattribute__(self, name)
+
+ return getattrMethod
+
+def generateSetattrMethod(factory, class_definition, classinfos):
+ attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
+ optional_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "optional"])
+ elements = OrderedDict([(element["name"], element) for element in classinfos["elements"]])
+
+ def setattrMethod(self, name, value):
+ if attributes.has_key(name):
+ attribute_infos = attributes[name]
+ attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"])
+ if optional_attributes.get(name, False):
+ default = attribute_infos.get("default", None)
+ if value is None or value == default:
+ self.attrib.pop(name, None)
+ return
+ elif attribute_infos.has_key("fixed"):
+ return
+ return self.set(name, attribute_infos["attr_type"]["generate"](value))
+
+ elif elements.has_key(name):
+ element_infos = elements[name]
+ element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])
+ if element_infos["type"] == ANY:
+ element_infos["elmt_type"]["generate"](self, value)
+
+ elif name == "content" and element_infos["elmt_type"]["type"] == SIMPLETYPE:
+ self.text = element_infos["elmt_type"]["generate"](value)
+
+ else:
+ prefix = ("%s:" % factory.TargetNamespace
+ if factory.TargetNamespace is not None else "")
+ element_xpath = (prefix + name
+ if name != "content"
+ else elements["content"]["elmt_type"]["choices_xpath"].path)
+
+ for element in self.xpath(element_xpath, namespaces=factory.NSMAP):
+ self.remove(element)
+
+ if value is not None:
+ element_idx = elements.keys().index(name)
+ if element_idx > 0:
+ previous_elements_xpath = "|".join(map(
+ lambda x: prefix + x
+ if x != "content"
+ else elements["content"]["elmt_type"]["choices_xpath"].path,
+ elements.keys()[:element_idx]))
+
+ insertion_point = len(self.xpath(previous_elements_xpath, namespaces=factory.NSMAP))
else:
- getattr(self, name).append(elements[name]["elmt_type"]["extract"](node))
- else:
- object.__setattr__(self, name, elements[name]["elmt_type"]["extract"](node))
- elif elements.has_key("text"):
- if elements["text"]["maxOccurs"] == "unbounded" or elements["text"]["maxOccurs"] > 1:
- if first.get("text", True):
- object.__setattr__(self, "text", [elements["text"]["elmt_type"]["extract"](node)])
- first["text"] = False
- else:
- getattr(self, "text").append(elements["text"]["elmt_type"]["extract"](node))
- else:
- object.__setattr__(self, "text", elements["text"]["elmt_type"]["extract"](node))
- elif elements.has_key("content"):
- if name in ["#cdata-section", "#text"]:
- if elements["content"]["elmt_type"]["type"] == SIMPLETYPE:
- object.__setattr__(self, "content", elements["content"]["elmt_type"]["extract"](node.data, False))
- else:
- content = getattr(self, "content")
- if elements["content"]["maxOccurs"] == "unbounded" or elements["content"]["maxOccurs"] > 1:
- if first.get("content", True):
- object.__setattr__(self, "content", [elements["content"]["elmt_type"]["extract"](node, None)])
- first["content"] = False
- else:
- content.append(elements["content"]["elmt_type"]["extract"](node, content))
- else:
- object.__setattr__(self, "content", elements["content"]["elmt_type"]["extract"](node, content))
- return loadXMLTreeMethod
-
-
-"""
-Method that generates the method for generating an xml text by following the
-attributes list defined
-"""
-def generateGenerateXMLText(factory, classinfos):
- def generateXMLTextMethod(self, name, indent=0, extras={}, derived=False):
- ind1, ind2 = getIndent(indent, name)
- if not derived:
- text = ind1 + u'<%s' % name
- else:
- text = u''
-
- first = True
-
- if not classinfos.has_key("base"):
- extras.update(self.extraAttrs)
- for attr, value in extras.iteritems():
- if not first and not self.singleLineAttributes:
- text += u'\n%s' % (ind2)
- text += u' %s=%s' % (attr, quoteattr(value))
- first = False
- extras.clear()
- for attr in classinfos["attributes"]:
- if attr["use"] != "prohibited":
- attr["attr_type"] = FindTypeInfos(factory, attr["attr_type"])
- value = getattr(self, attr["name"], None)
- if value != None:
- computed_value = attr["attr_type"]["generate"](value)
- else:
- computed_value = None
- if attr["use"] != "optional" or (value != None and \
- computed_value != attr.get("default", attr["attr_type"]["generate"](attr["attr_type"]["initial"]()))):
- if classinfos.has_key("base"):
- extras[attr["name"]] = computed_value
- else:
- if not first and not self.singleLineAttributes:
- text += u'\n%s' % (ind2)
- text += ' %s=%s' % (attr["name"], quoteattr(computed_value))
- first = False
- if classinfos.has_key("base"):
- first, new_text = classinfos["base"].generateXMLText(self, name, indent, extras, True)
- text += new_text
- else:
- first = True
- for element in classinfos["elements"]:
- element["elmt_type"] = FindTypeInfos(factory, element["elmt_type"])
- value = getattr(self, element["name"], None)
- if element["minOccurs"] == 0 and element["maxOccurs"] == 1:
- if value is not None:
- if first:
- text += u'>\n'
- first = False
- text += element["elmt_type"]["generate"](value, element["name"], indent + 1)
- elif element["minOccurs"] == 1 and element["maxOccurs"] == 1:
- if first:
- text += u'>\n'
- first = False
- if element["name"] == "content" and element["elmt_type"]["type"] == SIMPLETYPE:
- text += element["elmt_type"]["generate"](value)
- else:
- text += element["elmt_type"]["generate"](value, element["name"], indent + 1)
- else:
- if first and len(value) > 0:
- text += u'>\n'
- first = False
- for item in value:
- text += element["elmt_type"]["generate"](item, element["name"], indent + 1)
- if not derived:
- if first:
- text += u'/>\n'
- else:
- text += ind1 + u'</%s>\n' % (name)
- return text
- else:
- return first, text
- return generateXMLTextMethod
+ insertion_point = 0
+
+ if not isinstance(value, ListType):
+ value = [value]
+
+ for element in reversed(value):
+ if element_infos["elmt_type"]["type"] == SIMPLETYPE:
+ tmp_element = etree.Element(factory.etreeNamespaceFormat % name)
+ tmp_element.text = element_infos["elmt_type"]["generate"](element)
+ element = tmp_element
+ self.insert(insertion_point, element)
+
+ elif classinfos.has_key("base"):
+ return classinfos["base"].__setattr__(self, name, value)
+
+ else:
+ raise AttributeError("'%s' can't have an attribute '%s'." % (self.__class__.__name__, name))
+
+ return setattrMethod
def gettypeinfos(name, facets):
if facets.has_key("enumeration") and facets["enumeration"][0] is not None:
@@ -1611,7 +1432,7 @@
elements[parts[0]]["elmt_type"]["facets"])
value = getattr(self, parts[0], "")
elif parts[0] == "content":
- return self.content["value"].getElementInfos(self.content["name"], path)
+ return self.content.getElementInfos(self.content.getLocalTag(), path)
else:
attr = getattr(self, parts[0], None)
if attr is None:
@@ -1622,7 +1443,7 @@
return attr.getElementInfos(parts[0], parts[1])
elif elements.has_key("content"):
if len(parts) > 0:
- return self.content["value"].getElementInfos(name, path)
+ return self.content.getElementInfos(name, path)
elif classinfos.has_key("base"):
classinfos["base"].getElementInfos(name, path)
else:
@@ -1640,15 +1461,9 @@
if self.content is None:
value = ""
else:
- value = self.content["name"]
- if self.content["value"] is not None:
- if self.content["name"] == "sequence":
- choices_dict = dict([(choice["name"], choice) for choice in element["choices"]])
- sequence_infos = choices_dict.get("sequence", None)
- if sequence_infos is not None:
- children.extend([item.getElementInfos(infos["name"]) for item, infos in zip(self.content["value"], sequence_infos["elements"])])
- else:
- children.extend(self.content["value"].getElementInfos(self.content["name"])["children"])
+ value = self.content.getLocalTag()
+ if self.content is not None:
+ children.extend(self.content.getElementInfos(value)["children"])
elif element["elmt_type"]["type"] == SIMPLETYPE:
children.append({"name": element_name, "require": element["minOccurs"] != 0,
"type": gettypeinfos(element["elmt_type"]["basename"],
@@ -1705,13 +1520,13 @@
instance.setElementValue(None, value)
elif elements.has_key("content"):
if len(parts) > 0:
- self.content["value"].setElementValue(path, value)
+ self.content.setElementValue(path, value)
elif classinfos.has_key("base"):
classinfos["base"].setElementValue(self, path, value)
elif elements.has_key("content"):
if value == "":
if elements["content"]["minOccurs"] == 0:
- self.setcontent(None)
+ self.setcontent([])
else:
raise ValueError("\"content\" element is required!")
else:
@@ -1723,20 +1538,21 @@
"""
def generateInitMethod(factory, classinfos):
def initMethod(self):
- self.extraAttrs = {}
if classinfos.has_key("base"):
- classinfos["base"].__init__(self)
+ classinfos["base"]._init_(self)
for attribute in classinfos["attributes"]:
attribute["attr_type"] = FindTypeInfos(factory, attribute["attr_type"])
if attribute["use"] == "required":
- setattr(self, attribute["name"], attribute["attr_type"]["initial"]())
- elif attribute["use"] == "optional":
- if attribute.has_key("default"):
- setattr(self, attribute["name"], attribute["attr_type"]["extract"](attribute["default"], False))
- else:
- setattr(self, attribute["name"], None)
+ self.set(attribute["name"], attribute["attr_type"]["generate"](attribute["attr_type"]["initial"]()))
for element in classinfos["elements"]:
- setattr(self, element["name"], GetElementInitialValue(factory, element))
+ if element["type"] != CHOICE:
+ element_name = (
+ etree.QName(factory.NSMAP["xhtml"], "p")
+ if element["type"] == ANY
+ else factory.etreeNamespaceFormat % element["name"])
+ initial = GetElementInitialValue(factory, element)
+ if initial is not None:
+ map(self.append, initial)
return initMethod
def generateSetMethod(attr):
@@ -1753,18 +1569,16 @@
def addMethod(self):
if infos["type"] == ATTRIBUTE:
infos["attr_type"] = FindTypeInfos(factory, infos["attr_type"])
- initial = infos["attr_type"]["initial"]
- extract = infos["attr_type"]["extract"]
+ if not infos.has_key("default"):
+ setattr(self, attr, infos["attr_type"]["initial"]())
elif infos["type"] == ELEMENT:
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- initial = infos["elmt_type"]["initial"]
- extract = infos["elmt_type"]["extract"]
+ value = infos["elmt_type"]["initial"]()
+ DefaultElementClass.__setattr__(value, "tag", factory.etreeNamespaceFormat % attr)
+ setattr(self, attr, value)
+ value._init_()
else:
raise ValueError("Invalid class attribute!")
- if infos.has_key("default"):
- setattr(self, attr, extract(infos["default"], False))
- else:
- setattr(self, attr, initial())
return addMethod
def generateDeleteMethod(attr):
@@ -1777,10 +1591,10 @@
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
attr_list = getattr(self, attr)
if maxOccurs == "unbounded" or len(attr_list) < maxOccurs:
- if infos["elmt_type"]["check"](value):
- attr_list.append(value)
+ if len(attr_list) == 0:
+ setattr(self, attr, [value])
else:
- raise ValueError("\"%s\" value isn't valid!" % attr)
+ attr_list[-1].addnext(value)
else:
raise ValueError("There can't be more than %d values in \"%s\"!" % (maxOccurs, attr))
return appendMethod
@@ -1790,10 +1604,12 @@
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
attr_list = getattr(self, attr)
if maxOccurs == "unbounded" or len(attr_list) < maxOccurs:
- if infos["elmt_type"]["check"](value):
- attr_list.insert(index, value)
+ if len(attr_list) == 0:
+ setattr(self, attr, [value])
+ elif index == 0:
+ attr_list[0].addprevious(value)
else:
- raise ValueError("\"%s\" value isn't valid!" % attr)
+ attr_list[min(index - 1, len(attr_list) - 1)].addnext(value)
else:
raise ValueError("There can't be more than %d values in \"%s\"!" % (maxOccurs, attr))
return insertMethod
@@ -1805,24 +1621,26 @@
def generateSetChoiceByTypeMethod(factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def setChoiceMethod(self, type):
- if not choices.has_key(type):
- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)
- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])
- new_element = choices[type]["elmt_type"]["initial"]()
- self.content = {"name": type, "value": new_element}
- return new_element
+ def setChoiceMethod(self, content_type):
+ if not choices.has_key(content_type):
+ raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)
+ choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])
+ new_content = choices[content_type]["elmt_type"]["initial"]()
+ DefaultElementClass.__setattr__(new_content, "tag", factory.etreeNamespaceFormat % content_type)
+ self.content = new_content
+ return new_content
return setChoiceMethod
def generateAppendChoiceByTypeMethod(maxOccurs, factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def appendChoiceMethod(self, type):
- if not choices.has_key(type):
- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)
- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])
+ def appendChoiceMethod(self, content_type):
+ if not choices.has_key(content_type):
+ raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)
+ choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])
if maxOccurs == "unbounded" or len(self.content) < maxOccurs:
- new_element = choices[type]["elmt_type"]["initial"]()
- self.content.append({"name": type, "value": new_element})
+ new_element = choices[content_type]["elmt_type"]["initial"]()
+ DefaultElementClass.__setattr__(new_element, "tag", factory.etreeNamespaceFormat % content_type)
+ self.appendcontent(new_element)
return new_element
else:
raise ValueError("There can't be more than %d values in \"content\"!" % maxOccurs)
@@ -1830,13 +1648,14 @@
def generateInsertChoiceByTypeMethod(maxOccurs, factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def insertChoiceMethod(self, index, type):
- if not choices.has_key(type):
- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)
- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])
+ def insertChoiceMethod(self, index, content_type):
+ if not choices.has_key(content_type):
+ raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)
+ choices[type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])
if maxOccurs == "unbounded" or len(self.content) < maxOccurs:
- new_element = choices[type]["elmt_type"]["initial"]()
- self.content.insert(index, {"name" : type, "value" : new_element})
+ new_element = choices[content_type]["elmt_type"]["initial"]()
+ DefaultElementClass.__setattr__(new_element, "tag", factory.etreeNamespaceFormat % content_type)
+ self.insertcontent(index, new_element)
return new_element
else:
raise ValueError("There can't be more than %d values in \"content\"!" % maxOccurs)
@@ -1846,7 +1665,7 @@
def removeMethod(self, index):
attr_list = getattr(self, attr)
if len(attr_list) > minOccurs:
- getattr(self, attr).pop(index)
+ self.remove(attr_list[index])
else:
raise ValueError("There can't be less than %d values in \"%s\"!" % (minOccurs, attr))
return removeMethod
@@ -1857,16 +1676,127 @@
return countMethod
"""
-This function generate the classes from a class factory
+This function generate a xml parser from a class factory
"""
-def GenerateClasses(factory):
+
+NAMESPACE_PATTERN = re.compile("xmlns(?:\:[^\=]*)?=\"[^\"]*\" ")
+
+class DefaultElementClass(etree.ElementBase):
+
+ StructurePattern = re.compile("$")
+
+ def _init_(self):
+ pass
+
+ def getLocalTag(self):
+ return etree.QName(self.tag).localname
+
+ def tostring(self):
+ return NAMESPACE_PATTERN.sub("", etree.tostring(self, pretty_print=True))
+
+class XMLElementClassLookUp(etree.PythonElementClassLookup):
+
+ def __init__(self, classes, *args, **kwargs):
+ etree.PythonElementClassLookup.__init__(self, *args, **kwargs)
+ self.LookUpClasses = classes
+
+ def GetElementClass(self, element_tag, parent_tag=None, default=DefaultElementClass):
+ element_class = self.LookUpClasses.get(element_tag, (default, None))
+ if not isinstance(element_class, DictType):
+ if isinstance(element_class[0], (StringType, UnicodeType)):
+ return self.GetElementClass(element_class[0], default=default)
+ return element_class[0]
+
+ element_with_parent_class = element_class.get(parent_tag, default)
+ if isinstance(element_with_parent_class, (StringType, UnicodeType)):
+ return self.GetElementClass(element_with_parent_class, default=default)
+ return element_with_parent_class
+
+ def lookup(self, document, element):
+ parent = element.getparent()
+ element_class = self.GetElementClass(element.tag,
+ parent.tag if parent is not None else None)
+ if isinstance(element_class, ListType):
+ children = "".join([
+ "%s " % etree.QName(child.tag).localname
+ for child in element])
+ for possible_class in element_class:
+ if isinstance(possible_class, (StringType, UnicodeType)):
+ possible_class = self.GetElementClass(possible_class)
+ if possible_class.StructurePattern.match(children) is not None:
+ return possible_class
+ return element_class[0]
+ return element_class
+
+class XMLClassParser(etree.XMLParser):
+
+ def __init__(self, namespaces, default_namespace_format, base_class, *args, **kwargs):
+ etree.XMLParser.__init__(self, *args, **kwargs)
+ self.DefaultNamespaceFormat = default_namespace_format
+ self.NSMAP = namespaces
+ targetNamespace = etree.QName(default_namespace_format % "d").namespace
+ if targetNamespace is not None:
+ self.RootNSMAP = {
+ name if targetNamespace != uri else None: uri
+ for name, uri in namespaces.iteritems()}
+ else:
+ self.RootNSMAP = namespaces
+ self.BaseClass = base_class
+
+ def set_element_class_lookup(self, class_lookup):
+ etree.XMLParser.set_element_class_lookup(self, class_lookup)
+ self.ClassLookup = class_lookup
+
+ def Dumps(self, xml_obj):
+ return etree.tostring(xml_obj)
+
+ def Loads(self, xml_string):
+ return etree.fromstring(xml_string, self)
+
+ def CreateRoot(self):
+ if self.BaseClass is not None:
+ root = self.makeelement(
+ self.DefaultNamespaceFormat % self.BaseClass[0],
+ nsmap=self.RootNSMAP)
+ root._init_()
+ return root
+ return None
+
+ def GetElementClass(self, element_tag, parent_tag=None):
+ return self.ClassLookup.GetElementClass(
+ self.DefaultNamespaceFormat % element_tag,
+ self.DefaultNamespaceFormat % parent_tag
+ if parent_tag is not None else parent_tag,
+ None)
+
+ def CreateElement(self, element_tag, parent_tag=None, class_idx=None):
+ element_class = self.GetElementClass(element_tag, parent_tag)
+ if isinstance(element_class, ListType):
+ if class_idx is not None and class_idx < len(element_class):
+ new_element = element_class[class_idx]()
+ else:
+ raise ValueError, "No corresponding class found!"
+ else:
+ new_element = element_class()
+ DefaultElementClass.__setattr__(new_element, "tag", self.DefaultNamespaceFormat % element_tag)
+ new_element._init_()
+ return new_element
+
+def GenerateParser(factory, xsdstring):
ComputedClasses = factory.CreateClasses()
- if factory.FileName is not None and len(ComputedClasses) == 1:
- UpdateXMLClassGlobals(ComputedClasses[factory.FileName])
- return ComputedClasses[factory.FileName]
- else:
- UpdateXMLClassGlobals(ComputedClasses)
- return ComputedClasses
-
-def UpdateXMLClassGlobals(classes):
- globals().update(classes)
+
+ if factory.FileName is not None:
+ ComputedClasses = ComputedClasses[factory.FileName]
+ BaseClass = [(name, XSDclass) for name, XSDclass in ComputedClasses.items() if XSDclass.IsBaseClass]
+
+ parser = XMLClassParser(
+ factory.NSMAP,
+ factory.etreeNamespaceFormat,
+ BaseClass[0] if len(BaseClass) == 1 else None,
+ schema = etree.XMLSchema(etree.fromstring(xsdstring)),
+ strip_cdata = False, remove_blank_text=True)
+ class_lookup = XMLElementClassLookUp(factory.ComputedClassesLookUp)
+ parser.set_element_class_lookup(class_lookup)
+
+ return parser
+
--- a/xmlclass/xsdschema.py Thu Sep 26 20:47:36 2013 +0900
+++ b/xmlclass/xsdschema.py Fri Sep 27 09:32:39 2013 +0900
@@ -924,6 +924,8 @@
else:
factory.Namespaces[include_factory.TargetNamespace] = include_factory.Namespaces[include_factory.TargetNamespace]
factory.ComputedClasses.update(include_factory.ComputedClasses)
+ factory.ComputedClassesLookUp.update(include_factory.ComputedClassesLookUp)
+ factory.EquivalentClassesParent.update(include_factory.EquivalentClassesParent)
return None
def ReduceRedefine(factory, attributes, elements):
@@ -939,8 +941,10 @@
factory.BlockDefault = attributes["blockDefault"]
factory.FinalDefault = attributes["finalDefault"]
- if attributes.has_key("targetNamespace"):
- factory.TargetNamespace = factory.DefinedNamespaces.get(attributes["targetNamespace"], None)
+ targetNamespace = attributes.get("targetNamespace", None)
+ factory.TargetNamespace = factory.DefinedNamespaces.get(targetNamespace, None)
+ if factory.TargetNamespace is not None:
+ factory.etreeNamespaceFormat = "{%s}%%s" % targetNamespace
factory.Namespaces[factory.TargetNamespace] = {}
annotations, children = factory.ReduceElements(elements, True)
@@ -1030,15 +1034,14 @@
schema = child
break
for qualified_name, attr in schema._attrs.items():
- value = GetAttributeValue(attr)
- if value == "http://www.w3.org/2001/XMLSchema":
- namespace, name = DecomposeQualifiedName(qualified_name)
- if namespace == "xmlns":
- self.DefinedNamespaces["http://www.w3.org/2001/XMLSchema"] = name
+ namespace, name = DecomposeQualifiedName(qualified_name)
+ if namespace == "xmlns":
+ value = GetAttributeValue(attr)
+ self.DefinedNamespaces[value] = name
+ self.NSMAP[name] = value
+ if value == "http://www.w3.org/2001/XMLSchema":
self.SchemaNamespace = name
- else:
- self.DefinedNamespaces["http://www.w3.org/2001/XMLSchema"] = self.SchemaNamespace
- self.Namespaces[self.SchemaNamespace] = XSD_NAMESPACE
+ self.Namespaces[self.SchemaNamespace] = XSD_NAMESPACE
self.Schema = XSD_NAMESPACE["schema"]["extract"]["default"](self, schema)
ReduceSchema(self, self.Schema[1], self.Schema[2])
@@ -1084,19 +1087,24 @@
return None
"""
-This function opens the xsd file and generate the classes from the xml tree
+This function opens the xsd file and generate a xml parser with class lookup from
+the xml tree
"""
-def GenerateClassesFromXSD(filepath):
+def GenerateParserFromXSD(filepath):
xsdfile = open(filepath, 'r')
- factory = XSDClassFactory(minidom.parse(xsdfile), filepath)
+ xsdstring = xsdfile.read()
xsdfile.close()
- return GenerateClasses(factory)
+ cwd = os.getcwd()
+ os.chdir(os.path.dirname(filepath))
+ parser = GenerateParser(XSDClassFactory(minidom.parseString(xsdstring), filepath), xsdstring)
+ os.chdir(cwd)
+ return parser
"""
-This function generate the classes from the xsd given as a string
+This function generate a xml from the xsd given as a string
"""
-def GenerateClassesFromXSDstring(xsdstring):
- return GenerateClasses(XSDClassFactory(minidom.parseString(xsdstring)))
+def GenerateParserFromXSDstring(xsdstring):
+ return GenerateParser(XSDClassFactory(minidom.parseString(xsdstring)), xsdstring)
#-------------------------------------------------------------------------------
@@ -2520,19 +2528,3 @@
"anyType": {"type": COMPLEXTYPE, "extract": lambda x:None},
}
-if __name__ == '__main__':
- classes = GenerateClassesFromXSD("test.xsd")
-
- # Code for test of test.xsd
- xmlfile = open("po.xml", 'r')
- tree = minidom.parse(xmlfile)
- xmlfile.close()
- test = classes["PurchaseOrderType"]()
- for child in tree.childNodes:
- if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "purchaseOrder":
- test.loadXMLTree(child)
- test.items.item[0].setquantity(2)
- testfile = open("test.xml", 'w')
- testfile.write(u'<?xml version=\"1.0\"?>\n')
- testfile.write(test.generateXMLText("purchaseOrder").encode("utf-8"))
- testfile.close()