beremiz: comparison PLCControler.py

equal deleted inserted replaced

-:72a826dfcfbb
+:02fe382c4511
 #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 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 collections import OrderedDict, namedtuple
-from plcopen import plcopen
-from plcopen.structures import *
+from plcopen import *
 from graphics.GraphicCommons import *
 from PLCGenerator import *
 duration_model = re.compile("(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:\.[0-9]*)?)ms)?")
 ITEM_VAR_INPUT,
 ITEM_VAR_OUTPUT,
 ITEM_VAR_INOUT
 ] = range(17, 24)
-VAR_CLASS_INFOS = {"Local" :    (plcopen.interface_localVars,    ITEM_VAR_LOCAL),
+VAR_CLASS_INFOS = {
-"Global" :   (plcopen.interface_globalVars,   ITEM_VAR_GLOBAL),
+"Local":    ("localVars",    ITEM_VAR_LOCAL),
-"External" : (plcopen.interface_externalVars, ITEM_VAR_EXTERNAL),
+"Global":   ("globalVars",   ITEM_VAR_GLOBAL),
-"Temp" :     (plcopen.interface_tempVars,     ITEM_VAR_TEMP),
+"External": ("externalVars", ITEM_VAR_EXTERNAL),
-"Input" :    (plcopen.interface_inputVars,    ITEM_VAR_INPUT),
+"Temp":     ("tempVars",     ITEM_VAR_TEMP),
-"Output" :   (plcopen.interface_outputVars,   ITEM_VAR_OUTPUT),
+"Input":    ("inputVars",    ITEM_VAR_INPUT),
-"InOut" :    (plcopen.interface_inOutVars,    ITEM_VAR_INOUT)
+"Output":   ("outputVars",   ITEM_VAR_OUTPUT),
-}
+"InOut":    ("inOutVars",    ITEM_VAR_INOUT)}
 POU_TYPES = {"program": ITEM_PROGRAM,
 "functionBlock": ITEM_FUNCTIONBLOCK,
 "function": ITEM_FUNCTION,
 }
 _("Configurations"), _("Resources"), _("Properties")]
 UNEDITABLE_NAMES = GetUneditableNames()
 [USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,
 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,
 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES
+#-------------------------------------------------------------------------------
+#                 Helper object for loading library in xslt stylesheets
+#-------------------------------------------------------------------------------
+class LibraryResolver(etree.Resolver):
+def __init__(self, controller, debug=False):
+self.Controller = controller
+self.Debug = debug
+def resolve(self, url, pubid, context):
+lib_name = os.path.basename(url)
+if lib_name in ["project", "stdlib", "extensions"]:
+lib_el = etree.Element(lib_name)
+if lib_name == "project":
+lib_el.append(deepcopy(self.Controller.GetProject(self.Debug)))
+elif lib_name == "stdlib":
+for lib in [StdBlockLibrary, AddnlBlockLibrary]:
+lib_el.append(deepcopy(lib))
+else:
+for ctn in self.Controller.ConfNodeTypes:
+lib_el.append(deepcopy(ctn["types"]))
+return self.resolve_string(etree.tostring(lib_el), context)
+#-------------------------------------------------------------------------------
+#           Helpers functions for translating list of arguments
+#                       from xslt to valid arguments
+#-------------------------------------------------------------------------------
+_BoolValue = lambda x: x in ["true", "0"]
+def _translate_args(translations, args):
+return [translate(arg[0]) if len(arg) > 0 else None
+for translate, arg in
+zip(translations, args)]
+#-------------------------------------------------------------------------------
+#                 Helpers object for generating pou var list
+#-------------------------------------------------------------------------------
+class _VariableInfos(object):
+__slots__ = ["Name", "Class", "Option", "Location", "InitialValue",
+"Edit", "Documentation", "Type", "Tree", "Number"]
+def __init__(self, *args):
+for attr, value in zip(self.__slots__, args):
+setattr(self, attr, value if value is not None else "")
+def copy(self):
+return _VariableInfos(*[getattr(self, attr) for attr in self.__slots__])
+class VariablesInfosFactory:
+def __init__(self, variables):
+self.Variables = variables
+self.TreeStack = []
+self.Type = None
+self.Dimensions = None
+def SetType(self, context, *args):
+self.Type = args[0][0]
+def GetType(self):
+if len(self.Dimensions) > 0:
+return ("array", self.Type, self.Dimensions)
+return self.Type
+def GetTree(self):
+return (self.TreeStack.pop(-1), self.Dimensions)
+def AddDimension(self, context, *args):
+self.Dimensions.append(tuple(
+_translate_args([str] * 2, args)))
+def AddTree(self, context, *args):
+self.TreeStack.append([])
+self.Dimensions = []
+def AddVarToTree(self, context, *args):
+var = (args[0][0], self.Type, self.GetTree())
+self.TreeStack[-1].append(var)
+def AddVariable(self, context, *args):
+self.Variables.append(_VariableInfos(*(_translate_args(
+[str] * 5 + [_BoolValue] + [str], args) +
+[self.GetType(), self.GetTree()])))
+#-------------------------------------------------------------------------------
+#            Helpers object for generating pou variable instance list
+#-------------------------------------------------------------------------------
+def class_extraction(value):
+class_type = {
+"configuration": ITEM_CONFIGURATION,
+"resource": ITEM_RESOURCE,
+"action": ITEM_ACTION,
+"transition": ITEM_TRANSITION,
+"program": ITEM_PROGRAM}.get(value)
+if class_type is not None:
+return class_type
+pou_type = POU_TYPES.get(value)
+if pou_type is not None:
+return pou_type
+var_type = VAR_CLASS_INFOS.get(value)
+if var_type is not None:
+return var_type[1]
+return None
+class _VariablesTreeItemInfos(object):
+__slots__ = ["name", "var_class", "type", "edit", "debug", "variables"]
+def __init__(self, *args):
+for attr, value in zip(self.__slots__, args):
+setattr(self, attr, value if value is not None else "")
+def copy(self):
+return _VariableTreeItem(*[getattr(self, attr) for attr in self.__slots__])
+class VariablesTreeInfosFactory:
+def __init__(self):
+self.Root = None
+def GetRoot(self):
+return self.Root
+def SetRoot(self, context, *args):
+self.Root = _VariablesTreeItemInfos(
+*([''] + _translate_args(
+[class_extraction, str] + [_BoolValue] * 2,
+args) + [[]]))
+def AddVariable(self, context, *args):
+if self.Root is not None:
+self.Root.variables.append(_VariablesTreeItemInfos(
+*(_translate_args(
+[str, class_extraction, str] + [_BoolValue] * 2,
+args) + [[]])))
+#-------------------------------------------------------------------------------
+#            Helpers object for generating instances path list
+#-------------------------------------------------------------------------------
+class InstancesPathFactory:
+def __init__(self, instances):
+self.Instances = instances
+def AddInstance(self, context, *args):
+self.Instances.append(args[0][0])
+#-------------------------------------------------------------------------------
+#            Helpers object for generating instance tagname
+#-------------------------------------------------------------------------------
+class InstanceTagName:
+def __init__(self, controller):
+self.Controller = controller
+self.TagName = None
+def GetTagName(self):
+return self.TagName
+def ConfigTagName(self, context, *args):
+self.TagName = self.Controller.ComputeConfigurationName(args[0][0])
+def ResourceTagName(self, context, *args):
+self.TagName = self.Controller.ComputeConfigurationResourceName(args[0][0], args[1][0])
+def PouTagName(self, context, *args):
+self.TagName = self.Controller.ComputePouName(args[0][0])
+def ActionTagName(self, context, *args):
+self.TagName = self.Controller.ComputePouActionName(args[0][0], args[0][1])
+def TransitionTagName(self, context, *args):
+self.TagName = self.Controller.ComputePouTransitionName(args[0][0], args[0][1])
+#-------------------------------------------------------------------------------
+#           Helpers object for generating pou block instances list
+#-------------------------------------------------------------------------------
+_Point = namedtuple("Point", ["x", "y"])
+_BlockInstanceInfos = namedtuple("BlockInstanceInfos",
+["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])
+_BlockSpecificValues = (
+namedtuple("BlockSpecificValues",
+["name", "execution_order"]),
+[str, int])
+_VariableSpecificValues = (
+namedtuple("VariableSpecificValues",
+["name", "value_type", "execution_order"]),
+[str, str, int])
+_ConnectionSpecificValues = (
+namedtuple("ConnectionSpecificValues", ["name"]),
+[str])
+_PowerRailSpecificValues = (
+namedtuple("PowerRailSpecificValues", ["connectors"]),
+[int])
+_LDElementSpecificValues = (
+namedtuple("LDElementSpecificValues",
+["name", "negated", "edge", "storage", "execution_order"]),
+[str, _BoolValue, str, str, int])
+_DivergenceSpecificValues = (
+namedtuple("DivergenceSpecificValues", ["connectors"]),
+[int])
+_SpecificValuesTuples = {
+"comment": (
+namedtuple("CommentSpecificValues", ["content"]),
+[str]),
+"input": _VariableSpecificValues,
+"output": _VariableSpecificValues,
+"inout": _VariableSpecificValues,
+"connector": _ConnectionSpecificValues,
+"continuation": _ConnectionSpecificValues,
+"leftPowerRail": _PowerRailSpecificValues,
+"rightPowerRail": _PowerRailSpecificValues,
+"contact": _LDElementSpecificValues,
+"coil": _LDElementSpecificValues,
+"step": (
+namedtuple("StepSpecificValues", ["name", "initial", "action"]),
+[str, _BoolValue, lambda x: x]),
+"transition": (
+namedtuple("TransitionSpecificValues",
+["priority", "condition_type", "condition", "connection"]),
+[int, str, str, lambda x: x]),
+"selectionDivergence": _DivergenceSpecificValues,
+"selectionConvergence": _DivergenceSpecificValues,
+"simultaneousDivergence": _DivergenceSpecificValues,
+"simultaneousConvergence": _DivergenceSpecificValues,
+"jump": (
+namedtuple("JumpSpecificValues", ["target"]),
+[str]),
+"actionBlock": (
+namedtuple("ActionBlockSpecificValues", ["actions"]),
+[lambda x: x]),
+}
+_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",
+["name", "negated", "edge", "position", "links"])
+_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",
+["refLocalId", "formalParameter", "points"])
+class _ActionInfos(object):
+__slots__ = ["qualifier", "type", "value", "duration", "indicator"]
+def __init__(self, *args):
+for attr, value in zip(self.__slots__, args):
+setattr(self, attr, value if value is not None else "")
+def copy(self):
+return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])
+class BlockInstanceFactory:
+def __init__(self, block_instances):
+self.BlockInstances = block_instances
+self.CurrentInstance = None
+self.SpecificValues = None
+self.CurrentConnection = None
+self.CurrentLink = None
+def SetSpecificValues(self, context, *args):
+self.SpecificValues = list(args)
+self.CurrentInstance = None
+self.CurrentConnection = None
+self.CurrentLink = None
+def AddBlockInstance(self, context, *args):
+specific_values_tuple, specific_values_translation = \
+_SpecificValuesTuples.get(args[0][0], _BlockSpecificValues)
+if (args[0][0] == "step" and len(self.SpecificValues) < 3 or
+args[0][0] == "transition" and len(self.SpecificValues) < 4):
+self.SpecificValues.append([None])
+elif args[0][0] == "actionBlock" and len(self.SpecificValues) < 1:
+self.SpecificValues.append([[]])
+specific_values = specific_values_tuple(*_translate_args(
+specific_values_translation, self.SpecificValues))
+self.SpecificValues = None
+self.CurrentInstance = _BlockInstanceInfos(
+*(_translate_args([str, int] + [float] * 4, args) +
+[specific_values, [], []]))
+self.BlockInstances[self.CurrentInstance.id] = self.CurrentInstance
+def AddInstanceConnection(self, context, *args):
+connection_args = _translate_args(
+[str, str, _BoolValue, str, float, float], args)
+self.CurrentConnection = _InstanceConnectionInfos(
+*(connection_args[1:4] + [
+_Point(*connection_args[4:6]), []]))
+if self.CurrentInstance is not None:
+if connection_args[0] == "input":
+self.CurrentInstance.inputs.append(self.CurrentConnection)
+else:
+self.CurrentInstance.outputs.append(self.CurrentConnection)
+else:
+self.SpecificValues.append([self.CurrentConnection])
+def AddConnectionLink(self, context, *args):
+self.CurrentLink = _ConnectionLinkInfos(
+*(_translate_args([int, str], args) + [[]]))
+self.CurrentConnection.links.append(self.CurrentLink)
+def AddLinkPoint(self, context, *args):
+self.CurrentLink.points.append(_Point(
+*_translate_args([float] * 2, args)))
+def AddAction(self, context, *args):
+if len(self.SpecificValues) == 0:
+self.SpecificValues.append([[]])
+translated_args = _translate_args([str] * 5, args)
+self.SpecificValues[0][0].append(_ActionInfos(*translated_args))
+pou_block_instances_xslt = etree.parse(
+os.path.join(ScriptDirectory, "plcopen", "pou_block_instances.xslt"))
 #-------------------------------------------------------------------------------
 #                         Undo Buffer for PLCOpenEditor
 #-------------------------------------------------------------------------------
 self.ProgramChunks = []
 self.ProgramOffset = 0
 self.NextCompiledProject = None
 self.CurrentCompiledProject = None
 self.ConfNodeTypes = []
+self.TotalTypesDict = StdBlckDct.copy()
+self.TotalTypes = StdBlckLst[:]
 self.ProgramFilePath = ""
 def GetQualifierTypes(self):
-return plcopen.QualifierList
+return QualifierList
 def GetProject(self, debug = False):
 if debug and self.CurrentCompiledProject is not None:
 return self.CurrentCompiledProject
 else:
 return self.Project is not None
 # 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 = []
 self.ProgramOffset = 0
 self.NextCompiledProject = self.Copy(self.Project)
 variables = []
 project = self.GetProject(debug)
 if project is not None:
 for pou in project.getpous():
 if pou_name is None or pou_name == pou.getname():
-variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou, debug)])
+variables.extend([var.Name for var in self.GetPouInterfaceVars(pou, debug=debug)])
 for transition in pou.gettransitionList():
 variables.append(transition.getname())
 for action in pou.getactionList():
 variables.append(action.getname())
 return variables
 infos["values"] = [datatypes, pou_types["function"], pou_types["functionBlock"],
 pou_types["program"], configurations]
 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:
+factory = VariablesTreeInfosFactory()
+parser = etree.XMLParser()
+parser.resolvers.add(LibraryResolver(self, debug))
+pou_variable_xslt_tree = etree.XSLT(
+etree.parse(
+os.path.join(ScriptDirectory, "plcopen", "pou_variables.xslt"),
+parser),
+extensions = {("pou_vars_ns", name): getattr(factory, name)
+for name in ["SetRoot", "AddVariable"]})
+obj = None
 words = tagname.split("::")
 if words[0] == "P":
-pou = project.getpou(words[1])
+obj = self.GetPou(words[1], debug)
-if pou is not None:
+elif words[0] != "D":
-pou_type = pou.getpouType()
+obj = self.GetEditedElement(tagname, debug)
-if (pou_type in ["program", "functionBlock"] and
+if obj is not None:
-pou.interface is not None):
+pou_variable_xslt_tree(obj)
-# Extract variables from every varLists
+return factory.GetRoot()
-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):
+def GetInstanceList(self, root, name, debug = False):
 instances = []
-for varlist in varlists:
+project = self.GetProject(debug)
-for variable in varlist.getvariable():
+if project is not None:
-vartype_content = variable.gettype().getcontent()
+factory = InstancesPathFactory(instances)
-if vartype_content["name"] == "derived":
-var_path = "%s.%s" % (parent_path, variable.getname())
+parser = etree.XMLParser()
-var_type = vartype_content["value"].getname()
+parser.resolvers.add(LibraryResolver(self, debug))
-if var_type == pou_type:
-instances.append(var_path)
+instances_path_xslt_tree = etree.XSLT(
-else:
+etree.parse(
-pou = project.getpou(var_type)
+os.path.join(ScriptDirectory, "plcopen", "instances_path.xslt"),
-if pou is not None and project.ElementIsUsedBy(pou_type, var_type):
+parser),
-instances.extend(
+extensions = {
-self.RecursiveSearchPouInstances(
+("instances_ns", "AddInstance"): factory.AddInstance})
-project, pou_type, var_path,
-[varlist for type, varlist in pou.getvars()],
+instances_path_xslt_tree(root,
-debug))
+instance_type=etree.XSLT.strparam(name))
 return instances
 def SearchPouInstances(self, tagname, debug = False):
 project = self.GetProject(debug)
 if project is not None:
 words = tagname.split("::")
 if words[0] == "P":
-instances = []
+return self.GetInstanceList(project, words[1])
-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
 elif words[0] == 'C':
 return [words[1]]
 elif words[0] == 'R':
 return ["%s.%s" % (words[1], words[2])]
 elif words[0] in ['T', 'A']:
 return ["%s.%s" % (instance, words[2])
 for instance in self.SearchPouInstances(
 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(".")
+factory = InstanceTagName(self)
-if len(parts) == 1:
-return self.ComputeConfigurationName(parts[0])
+parser = etree.XMLParser()
-elif len(parts) == 2:
+parser.resolvers.add(LibraryResolver(self, debug))
-for config in project.getconfigurations():
-if config.getname() == parts[0]:
+instance_tagname_xslt_tree = etree.XSLT(
-result = self.GetGlobalInstanceTagName(project,
+etree.parse(
-config,
+os.path.join(ScriptDirectory, "plcopen", "instance_tagname.xslt"),
-parts[1:],
+parser),
-debug)
+extensions = {("instance_tagname_ns", name): getattr(factory, name)
-if result is not None:
+for name in ["ConfigTagName", "ResourceTagName",
-return result
+"PouTagName", "ActionTagName",
-return self.ComputeConfigurationResourceName(parts[0], parts[1])
+"TransitionTagName"]})
-else:
-for config in project.getconfigurations():
+instance_tagname_xslt_tree(project,
-if config.getname() == parts[0]:
+instance_path=etree.XSLT.strparam(instance_path))
-for resource in config.getresource():
-if resource.getname() == parts[1]:
+return factory.GetTagName()
-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)
-return None
 def GetInstanceInfos(self, instance_path, debug = False):
 tagname = self.GetPouInstanceTagName(instance_path)
 if tagname is not None:
 infos = self.GetPouVariables(tagname, debug)
-infos["type"] = tagname
+infos.type = tagname
 return infos
 else:
 pou_path, var_name = instance_path.rsplit(".", 1)
 tagname = self.GetPouInstanceTagName(pou_path)
 if tagname is not None:
 pou_infos = self.GetPouVariables(tagname, debug)
-for var_infos in pou_infos["variables"]:
+for var_infos in pou_infos.variables:
-if var_infos["name"] == var_name:
+if var_infos.name == var_name:
 return var_infos
 return None
 # Return if data type given by name is used by another data type or pou
 def DataTypeIsUsed(self, name, debug = False):
 project = self.GetProject(debug)
 if project is not None:
-return project.ElementIsUsed(name) or project.DataTypeIsDerived(name)
+return len(self.GetInstanceList(project, name, debug)) > 0
 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 len(self.GetInstanceList(project, name, debug)) > 0
 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)
+pou_infos = self.GetPou(reference, debug)
-if project is not None:
+if pou_infos is not None:
-return project.ElementIsUsedBy(name, reference)
+return len(self.GetInstanceList(pou_infos, name, debug)) > 0
 return False
 def GenerateProgram(self, filepath=None):
 errors = []
 warnings = []
 def ProjectChangePouType(self, name, pou_type):
 if self.Project is not None:
 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):
 '''
 Adds the POU defined by 'pou_xml' to the current project with type 'pou_type'
 '''
 try:
-tree = minidom.parseString(pou_xml.encode("utf-8"))
+new_pou, error = LoadPou(pou_xml)
-root = tree.childNodes[0]
 except:
+error = ""
+if error is not None:
 return _("Couldn't paste non-POU object.")
-if root.nodeName == "pou":
+name = new_pou.getname()
-new_pou = plcopen.pous_pou()
-new_pou.loadXMLTree(root)
+idx = 0
+new_name = name
-name = new_pou.getname()
+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
+# we've found a name that does not already exist, use it
-new_name = name
+new_pou.setname(new_name)
-while self.Project.getpou(new_name):
-# a POU with that name already exists.
+if pou_type is not None:
-# make a new name and test if a POU with that name exists.
+orig_type = new_pou.getpouType()
-# append an incrementing numeric suffix to the POU name.
-idx += 1
+# prevent violations of POU content restrictions:
-new_name = "%s%d" % (name, idx)
+# function blocks cannot be pasted as functions,
+# programs cannot be pasted as functions or function blocks
-# we've found a name that does not already exist, use it
+if orig_type == 'functionBlock' and pou_type == 'function' or \
-new_pou.setname(new_name)
+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:
+new_pou.setpouType(pou_type)
-orig_type = new_pou.getpouType()
+self.Project.insertpou(-1, new_pou)
-# prevent violations of POU content restrictions:
+self.BufferProject()
-# function blocks cannot be pasted as functions,
-# programs cannot be pasted as functions or function blocks
+return self.ComputePouName(new_name),
-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.")
 # Remove a Pou from project
 def ProjectRemovePou(self, pou_name):
 if self.Project is not None:
 self.Project.removepou(pou_name)
 # Found the pou corresponding to old name and change its name to new name
 datatype = self.Project.getdataType(old_name)
 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
 def ChangePouName(self, old_name, new_name):
 if self.Project is not None:
 # Found the pou corresponding to old name and change its name to new name
 pou = self.Project.getpou(old_name)
 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
 def ChangePouTransitionName(self, pou_name, old_name, new_name):
 if self.Project is not None:
 if pou is not None:
 for type, varlist in pou.getvars():
 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
 def ChangeConfigurationName(self, old_name, new_name):
 if self.Project is not None:
 if project is not None:
 # Found the pou correponding to name and return its type
 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
 def GetPouType(self, name, debug = False):
 project = self.GetProject(debug)
 def ExtractVarLists(self, vars):
 varlist_list = []
 current_varlist = None
 current_type = None
 for var in vars:
-next_type = (var["Class"],
+next_type = (var.Class,
-var["Option"],
+var.Option,
-var["Location"] in ["", None] or
+var.Location in ["", None] or
 # When declaring globals, located
 # and not located variables are
 # in the same declaration block
-var["Class"] == "Global")
+var.Class == "Global")
 if current_type != next_type:
 current_type = next_type
-infos = VAR_CLASS_INFOS.get(var["Class"], None)
+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))
+varlist_list.append((var.Class, current_varlist))
-if var["Option"] == "Constant":
+if var.Option == "Constant":
 current_varlist.setconstant(True)
-elif var["Option"] == "Retain":
+elif var.Option == "Retain":
 current_varlist.setretain(True)
-elif var["Option"] == "Non-Retain":
+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"])
+tempvar.setname(var.Name)
-var_type = plcopen.dataType()
+var_type = PLCOpenParser.CreateElement("type", "variable")
-if isinstance(var["Type"], TupleType):
+if isinstance(var.Type, TupleType):
-if var["Type"][0] == "array":
+if var.Type[0] == "array":
-array_type, base_type_name, dimensions = var["Type"]
+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 = PLCOpenParser.CreateElement("dimension", "array")
-dimension_range.setlower(dimension[0])
-dimension_range.setupper(dimension[1])
 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":
+baseType.setcontent(PLCOpenParser.CreateElement(
-array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+base_type_name.lower()
-elif base_type_name == "WSTRING":
+if base_type_name in ["STRING", "WSTRING"]
-array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
+else base_type_name, "dataType"))
-else:
-array.baseType.setcontent({"name" : base_type_name, "value" : None})
 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})
+baseType.setcontent(derived_datatype)
-var_type.setcontent({"name" : "array", "value" : array})
+var_type.setcontent(array)
-elif var["Type"] in self.GetBaseTypes():
+elif var.Type in self.GetBaseTypes():
-if var["Type"] == "STRING":
+var_type.setcontent(PLCOpenParser.CreateElement(
-var_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+var.Type.lower()
-elif var["Type"] == "WSTRING":
+if var.Type in ["STRING", "WSTRING"]
-var_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
+else var.Type, "dataType"))
-else:
-var_type.setcontent({"name" : var["Type"], "value" : None})
 else:
-derived_type = plcopen.derivedTypes_derived()
+derived_type = PLCOpenParser.CreateElement("derived", "dataType")
-derived_type.setname(var["Type"])
+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"] != "":
+if var.InitialValue != "":
-value = plcopen.value()
+value = PLCOpenParser.CreateElement("initialValue", "variable")
-value.setvalue(var["Initial Value"])
+value.setvalue(var.InitialValue)
 tempvar.setinitialValue(value)
-if var["Location"] != "":
+if var.Location != "":
-tempvar.setaddress(var["Location"])
+tempvar.setaddress(var.Location)
 else:
 tempvar.setaddress(None)
-if var['Documentation'] != "":
+if var.Documentation != "":
-ft = plcopen.formattedText()
+ft = PLCOpenParser.CreateElement("documentation", "variable")
-ft.settext(var['Documentation'])
+ft.setanyText(var.Documentation)
 tempvar.setdocumentation(ft)
 # Add variable to varList
 current_varlist.appendvariable(tempvar)
 return varlist_list
-def GetVariableDictionary(self, varlist, var):
+def GetVariableDictionary(self, object_with_vars, tree=False, debug=False):
-'''
+variables = []
-convert a PLC variable to the dictionary representation
+factory = VariablesInfosFactory(variables)
-returned by Get*Vars)
-'''
+parser = etree.XMLParser()
+parser.resolvers.add(LibraryResolver(self, debug))
-tempvar = {"Name": var.getname()}
+variables_infos_xslt_tree = etree.XSLT(
-vartype_content = var.gettype().getcontent()
+etree.parse(
-if vartype_content["name"] == "derived":
+os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),
-tempvar["Type"] = vartype_content["value"].getname()
+parser),
-elif vartype_content["name"] == "array":
+extensions = {("var_infos_ns", name): getattr(factory, name)
-dimensions = []
+for name in ["SetType", "AddDimension", "AddTree",
-for dimension in vartype_content["value"].getdimension():
+"AddVarToTree", "AddVariable"]})
-dimensions.append((dimension.getlower(), dimension.getupper()))
+variables_infos_xslt_tree(object_with_vars,
-base_type = vartype_content["value"].baseType.getcontent()
+tree=etree.XSLT.strparam(str(tree)))
-if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
-base_type_name = base_type["name"].upper()
+return variables
-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
 # 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):
 if self.Project is not None:
 # Found the configuration corresponding to name
 configuration = self.Project.getconfiguration(name)
 if configuration is not None:
 # Set configuration global vars
-configuration.setglobalVars([])
+configuration.setglobalVars([
-for vartype, varlist in self.ExtractVarLists(vars):
+varlist for vartype, varlist
-configuration.globalVars.append(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
+# Extract variables defined in configuration
-for varlist in configuration.getglobalVars():
+return self.GetVariableDictionary(configuration, debug)
-for var in varlist.getvariable():
-tempvar = self.GetVariableDictionary(varlist, var)
+return []
-tempvar["Class"] = "Global"
-vars.append(tempvar)
-return vars
 # Return configuration variable names
 def GetConfigurationVariableNames(self, config_name = None, debug = False):
 variables = []
 project = self.GetProject(debug)
 if self.Project is not None:
 # Found the resource corresponding to name
 resource = self.Project.getconfigurationResource(config_name, name)
 # Set resource global vars
 if resource is not None:
-resource.setglobalVars([])
+resource.setglobalVars([
-for vartype, varlist in self.ExtractVarLists(vars):
+varlist for vartype, varlist
-resource.globalVars.append(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:
+if resource is not None:
-# Extract variables from every varLists
+# Extract variables defined in configuration
-for varlist in resource.getglobalVars():
+return self.GetVariableDictionary(resource, debug)
-for var in varlist.getvariable():
-tempvar = self.GetVariableDictionary(varlist, var)
+return []
-tempvar["Class"] = "Global"
-vars.append(tempvar)
-return vars
 # Return resource variable names
 def GetConfigurationResourceVariableNames(self,
 config_name = None, resource_name = None, debug = False):
 variables = []
 [var.getname() for var in reduce(
 lambda x, y: x + y, [varlist.getvariable()
 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):
+def GetPouInterfaceVars(self, pou, tree=False, debug = False):
-vars = []
+interface = pou.interface
 # Verify that the pou has an interface
-if pou.interface is not None:
+if interface is not None:
-# Extract variables from every varLists
+# Extract variables defined in interface
-for type, varlist in pou.getvars():
+return self.GetVariableDictionary(interface, tree, debug)
-for var in varlist.getvariable():
+return []
-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
 # Replace the Pou interface by the one given
 def SetPouInterfaceVars(self, name, vars):
 if self.Project is not None:
 # Found the pou corresponding to name and add interface if there isn't one yet
 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))
+pou.setvars([varlist for varlist_type, varlist in self.ExtractVarLists(vars)])
-self.Project.RefreshElementUsingTree()
-self.Project.RefreshCustomBlockTypes()
 # 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()
+return_type_obj = pou.interface.getreturnType()
-if not return_type:
+if return_type_obj is None:
-return_type = plcopen.dataType()
+return_type_obj = PLCOpenParser.CreateElement("returnType", "interface")
-pou.interface.setreturnType(return_type)
+pou.interface.setreturnType(return_type_obj)
 # Change return type
-if type in self.GetBaseTypes():
+if return_type in self.GetBaseTypes():
-if type == "STRING":
+return_type_obj.setcontent(PLCOpenParser.CreateElement(
-return_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+return_type.lower()
-elif type == "WSTRING":
+if return_type in ["STRING", "WSTRING"]
-return_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
+else return_type, "dataType"))
-else:
-return_type.setcontent({"name" : type, "value" : None})
 else:
-derived_type = plcopen.derivedTypes_derived()
+derived_type = PLCOpenParser.CreateElement("derived", "dataType")
-derived_type.setname(type)
+derived_type.setname(return_type)
-return_type.setcontent({"name" : "derived", "value" : derived_type})
+return_type.setcontent(derived_type)
-self.Project.RefreshElementUsingTree()
-self.Project.RefreshCustomBlockTypes()
 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
-def GetPouInterfaceReturnTypeByName(self, name):
-project = self.GetProject(debug)
-if project is not None:
-# Found the pou correponding to name and return the return type
-pou = project.getpou(name)
-if pou is not None:
-return self.GetPouInterfaceReturnType(pou)
-return False
 # Return the return type of the given pou
-def GetPouInterfaceReturnType(self, pou):
+def GetPouInterfaceReturnType(self, pou, tree=False, debug=False):
 # Verify that the pou has an interface
 if pou.interface is not None:
 # Return the return type if there is one
 return_type = pou.interface.getreturnType()
-if return_type:
+if return_type is not None:
-returntype_content = return_type.getcontent()
+factory = VariablesInfosFactory([])
-if returntype_content["name"] == "derived":
-return returntype_content["value"].getname()
+parser = etree.XMLParser()
-elif returntype_content["name"] in ["string", "wstring"]:
+if tree:
-return returntype_content["name"].upper()
+parser.resolvers.add(LibraryResolver(self))
-else:
-return returntype_content["name"]
+return_type_infos_xslt_tree = etree.XSLT(
+etree.parse(
+os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),
+parser),
+extensions = {("var_infos_ns", name): getattr(factory, name)
+for name in ["SetType", "AddDimension",
+"AddTree", "AddVarToTree"]})
+return_type_infos_xslt_tree(return_type,
+tree=etree.XSLT.strparam(str(tree)))
+if tree:
+return [factory.GetType(), factory.GetTree()]
+return factory.GetType()
+if tree:
+return [None, ([], [])]
 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": [pou.getblockInfos()
+for pou in confnodetypes["types"].getpous()]}
+for confnodetypes in typeslist]
+self.TotalTypes.extend(addedcat)
+for cat in addedcat:
+for desc in cat["list"]:
+BlkLst = self.TotalTypesDict.setdefault(desc["name"],[])
+BlkLst.append((section["name"], desc))
 # Function that clear the confnode list
 def ClearConfNodeTypes(self):
-for i in xrange(len(self.ConfNodeTypes)):
+self.ConfNodeTypes = []
-self.ConfNodeTypes.pop(0)
+self.TotalTypesDict = StdBlckDct.copy()
+self.TotalTypes = StdBlckLst[:]
-def GetConfNodeBlockTypes(self):
-return [{"name": _("%s POUs") % confnodetypes["name"],
+def GetConfNodeDataTypes(self, exclude = None, only_locatables = False):
-"list": confnodetypes["types"].GetCustomBlockTypes()}
+return [{"name": _("%s Data Types") % confnodetypes["name"],
+"list": [
+datatype.getname()
+for datatype in confnodetypes["types"].getdataTypes()
+if not only_locatables or self.IsLocatableDataType(datatype, debug)]}
 for confnodetypes in self.ConfNodeTypes]
-def GetConfNodeDataTypes(self, exclude = "", only_locatables = False):
-return [{"name": _("%s Data Types") % confnodetypes["name"],
-"list": [datatype["name"] for datatype in confnodetypes["types"].GetCustomDataTypes(exclude, only_locatables)]}
-for confnodetypes in self.ConfNodeTypes]
-def GetConfNodeDataType(self, type):
-for confnodetype in self.ConfNodeTypes:
-datatype = confnodetype["types"].getdataType(type)
-if datatype is not None:
-return datatype
-return None
 def GetVariableLocationTree(self):
 return []
 def GetConfNodeGlobalInstances(self):
 return []
 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(PLCOpenParser.CreateElement(
-tempvartype.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+var_type.lower()
-elif var_type == "WSTRING":
+if var_type in ["STRING", "WSTRING"]
-tempvartype.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
+else var_type, "dataType"))
-else:
-tempvartype.setcontent({"name" : var_type, "value" : None})
 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)
 global_vars.append(tempvar)
 return global_vars
 # Function that returns the block definition associated to the block type given
-def GetBlockType(self, type, inputs = None, debug = False):
+def GetBlockType(self, typename, inputs = None, debug = False):
 result_blocktype = None
-for category in BlockTypes + self.GetConfNodeBlockTypes():
+for sectioname, blocktype in self.TotalTypesDict.get(typename,[]):
-for blocktype in category["list"]:
+if inputs is not None and inputs != "undefined":
-if blocktype["name"] == type:
+block_inputs = tuple([var_type for name, var_type, modifier in blocktype["inputs"]])
-if inputs is not None and inputs != "undefined":
+if reduce(lambda x, y: x and y, map(lambda x: x[0] == "ANY" or self.IsOfType(*x), zip(inputs, block_inputs)), True):
-block_inputs = tuple([var_type for name, var_type, modifier in blocktype["inputs"]])
+return blocktype
-if reduce(lambda x, y: x and y, map(lambda x: x[0] == "ANY" or self.IsOfType(*x), zip(inputs, block_inputs)), True):
+else:
-return blocktype
+if result_blocktype is not None:
+if inputs == "undefined":
+return None
 else:
-if result_blocktype is not None:
+result_blocktype["inputs"] = [(i[0], "ANY", i[2]) for i in result_blocktype["inputs"]]
-if inputs == "undefined":
+result_blocktype["outputs"] = [(o[0], "ANY", o[2]) for o in result_blocktype["outputs"]]
-return None
+return result_blocktype
-else:
+result_blocktype = blocktype.copy()
-result_blocktype["inputs"] = [(i[0], "ANY", i[2]) for i in result_blocktype["inputs"]]
-result_blocktype["outputs"] = [(o[0], "ANY", o[2]) for o in result_blocktype["outputs"]]
-return result_blocktype
-result_blocktype = blocktype.copy()
 if result_blocktype is not None:
 return result_blocktype
 project = self.GetProject(debug)
 if project is not None:
-return project.GetCustomBlockType(type, 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
 def GetBlockTypes(self, tagname = "", debug = False):
-type = None
+typename = None
 words = tagname.split("::")
-if self.Project:
+name = None
-name = ""
+project = self.GetProject(debug)
+if project is not None:
+pou_type = None
 if words[0] in ["P","T","A"]:
 name = words[1]
-type = self.GetPouType(name, debug)
+pou_type = self.GetPouType(name, debug)
-if type == "function":
+filter = (["function"]
-blocktypes = []
+if pou_type == "function" or words[0] == "T"
-for category in BlockTypes + self.GetConfNodeBlockTypes():
+else ["functionBlock", "function"])
-cat = {"name" : category["name"], "list" : []}
+blocktypes = [
-for block in category["list"]:
+{"name": category["name"],
-if block["type"] == "function":
+"list": [block for block in category["list"]
-cat["list"].append(block)
+if block["type"] in filter]}
-if len(cat["list"]) > 0:
+for category in self.TotalTypes]
-blocktypes.append(cat)
+blocktypes.append({"name" : USER_DEFINED_POUS,
-else:
+"list": [pou.getblockInfos()
-blocktypes = [category for category in BlockTypes + self.GetConfNodeBlockTypes()]
+for pou in project.getpous(name, filter)
-project = self.GetProject(debug)
+if (name is None or
-if project is not None:
+len(self.GetInstanceList(pou, name, debug)) == 0)]})
-blocktypes.append({"name" : USER_DEFINED_POUS, "list": project.GetCustomBlockTypes(name, type == "function" or words[0] == "T")})
+return blocktypes
-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 category in BlockTypes + self.GetConfNodeBlockTypes():
+for blocks in self.TotalTypesDict.itervalues():
-for block in category["list"]:
+for sectioname,block in blocks:
 if block["type"] == "functionBlock":
 blocktypes.append(block["name"])
-project = self.GetProject(debug)
+if project is not None:
-if project is not None:
+blocktypes.extend([pou.getname()
-name = ""
+for pou in project.getpous(name, ["functionBlock"])
-words = tagname.split("::")
+if (name is None or
-if words[0] in ["P","T","A"]:
+len(self.GetInstanceList(pou, name, debug)) == 0)])
-name = words[1]
-blocktypes.extend(project.GetCustomFunctionBlockTypes(name))
 return blocktypes
 # Return Block types checking for recursion
 def GetBlockResource(self, debug = False):
 blocktypes = []
-for category in BlockTypes[:-1]:
+for category in StdBlckLst[:-1]:
 for blocktype in category["list"]:
 if blocktype["type"] == "program":
 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
 def GetDataTypes(self, tagname = "", basetypes = True, confnodetypes = True, only_locatables = False, debug = False):
 if basetypes:
 datatypes = self.GetBaseTypes()
 else:
 datatypes = []
 project = self.GetProject(debug)
-if project is not None:
+name = None
-name = ""
+if project is not None:
 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
+len(self.GetInstanceList(datatype, name, debug)) == 0)])
 if confnodetypes:
 for category in self.GetConfNodeDataTypes(name, only_locatables):
 datatypes.extend(category["list"])
 return datatypes
-# Return Base Type of given possible derived type
+# Return Data Type Object
-def GetBaseType(self, type, debug = False):
+def GetPou(self, typename, debug = False):
 project = self.GetProject(debug)
 if project is not None:
-result = project.GetBaseType(type)
+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())
+return (basetype_content.getname() if basetype_content_type == "derived"
+else basetype_content_type.upper())
+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.
 TypeHierarchy_list has a rough order to it (e.g. SINT, INT, DINT, ...),
 which makes it easy for a user to find a type in a menu.
 '''
 return [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]
-def IsOfType(self, type, reference, debug = False):
+def IsOfType(self, typename, reference, debug = False):
-if reference is None:
+if reference is None or typename == reference:
 return True
-elif type == reference:
-return True
+basetype = TypeHierarchy.get(typename)
-elif type in TypeHierarchy:
+if basetype is not None:
-return self.IsOfType(TypeHierarchy[type], reference)
+return self.IsOfType(basetype, reference)
-else:
-project = self.GetProject(debug)
+datatype = self.GetDataType(typename, debug)
-if project is not None and project.IsOfType(type, reference):
+if datatype is not None:
-return True
+basetype = self.GetDataTypeBaseType(datatype)
-for confnodetype in self.ConfNodeTypes:
+if basetype is not None:
-if confnodetype["types"].IsOfType(type, reference):
+return self.IsOfType(basetype, reference, debug)
-return True
 return False
-def IsEndType(self, type):
+def IsEndType(self, typename):
-if type is not None:
+if typename is not None:
-return not type.startswith("ANY")
+return not typename.startswith("ANY")
 return True
-def IsLocatableType(self, type, debug = False):
+def IsLocatableDataType(self, datatype, debug = False):
-if isinstance(type, TupleType):
+basetype_content = datatype.baseType.getcontent()
-return False
+basetype_content_type = basetype_content.getLocalTag()
-if self.GetBlockType(type) is not None:
+if basetype_content_type in ["enum", "struct"]:
 return False
-project = self.GetProject(debug)
+elif basetype_content_type == "derived":
-if project is not None:
+return self.IsLocatableType(basetype_content.getname())
-datatype = project.getdataType(type)
+elif basetype_content_type == "array":
-if datatype is None:
+array_base_type = basetype_content.baseType.getcontent()
-datatype = self.GetConfNodeDataType(type)
+if array_base_type.getLocalTag() == "derived":
-if datatype is not None:
+return self.IsLocatableType(array_base_type.getname(), debug)
-return project.IsLocatableType(datatype)
 return True
-def IsEnumeratedType(self, type, debug = False):
+def IsLocatableType(self, typename, debug = False):
-project = self.GetProject(debug)
+if isinstance(typename, TupleType) or self.GetBlockType(typename) is not None:
-if project is not None:
+return False
-datatype = project.getdataType(type)
-if datatype is None:
+datatype = self.GetDataType(typename, debug)
-datatype = self.GetConfNodeDataType(type)
+if datatype is not None:
-if datatype is not None:
+return self.IsLocatableDataType(datatype)
-basetype_content = datatype.baseType.getcontent()
+return True
-return basetype_content["name"] == "enum"
+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):
+def IsSubrangeType(self, typename, exclude=None, debug = False):
-return self.IsOfType(type, "ANY_NUM", debug) or\
+if typename == exclude:
-self.IsOfType(type, "ANY_BIT", debug)
+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):
+def GetDataTypeRange(self, typename, debug = False):
-if type in DataTypeRange:
+range = DataTypeRange.get(typename)
-return DataTypeRange[type]
+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)
+values.extend(project.GetEnumeratedDataTypeValues())
-if result is not None:
-return result
 for confnodetype in self.ConfNodeTypes:
-result = confnodetype["types"].GetDataTypeRange(type)
+values.extend(confnodetype["types"].GetEnumeratedDataTypeValues())
-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
 return values
 #-------------------------------------------------------------------------------
 #                   Project Element tag name computation functions
 #-------------------------------------------------------------------------------
 infos = {}
 datatype = project.getdataType(words[1])
 if datatype is None:
 return None
 basetype_content = datatype.baseType.getcontent()
-if basetype_content["value"] is None or basetype_content["name"] in ["string", "wstring"]:
+basetype_content_type = basetype_content.getLocalTag()
-infos["type"] = "Directly"
+if basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
-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"]:
 infos["type"] = "Subrange"
-infos["min"] = basetype_content["value"].range.getlower()
+infos["min"] = basetype_content.range.getlower()
-infos["max"] = basetype_content["value"].range.getupper()
+infos["max"] = basetype_content.range.getupper()
-base_type = basetype_content["value"].baseType.getcontent()
+base_type = basetype_content.baseType.getcontent()
-if base_type["value"] is None:
+base_type_type = base_type.getLocalTag()
-infos["base_type"] = base_type["name"]
+infos["base_type"] = (base_type.getname()
-else:
+if base_type_type == "derived"
-infos["base_type"] = base_type["value"].getname()
+else base_type_type)
-elif basetype_content["name"] == "enum":
+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()
+base_type = basetype_content.baseType.getcontent()
-if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
+base_type_type = base_type.getLocalTag()
-infos["base_type"] = base_type["name"].upper()
+infos["base_type"] = (base_type.getname()
-else:
+if base_type_type == "derived"
-infos["base_type"] = base_type["value"].getname()
+else base_type_type.upper())
-elif basetype_content["name"] == "struct":
+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_type_type = element_type.getLocalTag()
-element_infos["Type"] = element_type["name"].upper()
+if element_type_type == "array":
-elif element_type["name"] == "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()
+base_type = element_type.baseType.getcontent()
-if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
+base_type_type = element_type.getLocalTag()
-base_type_name = base_type["name"].upper()
+element_infos["Type"] = ("array",
-else:
+base_type.getname()
-base_type_name = base_type["value"].getname()
+if base_type_type == "derived"
-element_infos["Type"] = ("array", base_type_name, dimensions)
+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:
 infos["initial"] = ""
 return infos
 words = tagname.split("::")
 if self.Project is not None and words[0] == "D":
 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(PLCOpenParser.CreateElement(
-datatype.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+infos["base_type"].lower()
-elif infos["base_type"] == "WSTRING":
+if infos["base_type"] in ["STRING", "WSTRING"]
-datatype.baseType.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
+else infos["base_type"], "dataType"))
-else:
-datatype.baseType.setcontent({"name" : infos["base_type"], "value" : None})
 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 = PLCOpenParser.CreateElement(
-subrange = plcopen.derivedTypes_subrangeUnsigned()
+"subrangeUnsigned"
-datatype.baseType.setcontent({"name" : "subrangeUnsigned", "value" : subrange})
+if infos["base_type"] in GetSubTypes("ANY_UINT")
-else:
+else "subrangeSigned", "dataType")
-subrange = plcopen.derivedTypes_subrangeSigned()
+datatype.baseType.setcontent(subrange)
-datatype.baseType.setcontent({"name" : "subrangeSigned", "value" : 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)
+values.appendvalue(value)
-datatype.baseType.setcontent({"name" : "enum", "value" : enumerated})
 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:
 array.setdimension([dimension_range])
 else:
 array.appenddimension(dimension_range)
 if infos["base_type"] in self.GetBaseTypes():
-if infos["base_type"] == "STRING":
+array.baseType.setcontent(PLCOpenParser.CreateElement(
-array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+infos["base_type"].lower()
-elif infos["base_type"] == "WSTRING":
+if infos["base_type"] in ["STRING", "WSTRING"]
-array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
+else infos["base_type"], "dataType"))
-else:
-array.baseType.setcontent({"name" : infos["base_type"], "value" : None})
 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})
+array.baseType.setcontent(derived_datatype)
-datatype.baseType.setcontent({"name" : "array", "value" : array})
 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:
 array.setdimension([dimension_range])
 else:
 array.appenddimension(dimension_range)
 if base_type_name in self.GetBaseTypes():
-if base_type_name == "STRING":
+array.baseType.setcontent(PLCOpenParser.CreateElement(
-array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+base_type_name.lower()
-elif base_type_name == "WSTRING":
+if base_type_name in ["STRING", "WSTRING"]
-array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
+else base_type_name, "dataType"))
-else:
-array.baseType.setcontent({"name" : base_type_name, "value" : None})
 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})
+array.baseType.setcontent(derived_datatype)
-element.type.setcontent({"name" : "array", "value" : array})
 elif element_infos["Type"] in self.GetBaseTypes():
-if element_infos["Type"] == "STRING":
+element_type.setcontent(
-element.type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+PLCOpenParser.CreateElement(
-elif element_infos["Type"] == "WSTRING":
+element_infos["Type"].lower()
-element.type.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
+if element_infos["Type"] in ["STRING", "WSTRING"]
-else:
+else element_infos["Type"], "dataType"))
-element.type.setcontent({"name" : element_infos["Type"], "value" : None})
 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()
 #-------------------------------------------------------------------------------
 #                       Project opened Pous management functions
 #-------------------------------------------------------------------------------
 elif words[0] == 'A':
 return self.GetActionBodyType(words[1], words[2], debug)
 return None
 # Return the edited element variables
-def GetEditedElementInterfaceVars(self, tagname, debug = False):
+def GetEditedElementInterfaceVars(self, tagname, tree=False, debug = False):
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
 project = self.GetProject(debug)
 if project is not None:
 pou = project.getpou(words[1])
 if pou is not None:
-return self.GetPouInterfaceVars(pou, debug)
+return self.GetPouInterfaceVars(pou, tree, debug)
 return []
 # Return the edited element return type
-def GetEditedElementInterfaceReturnType(self, tagname, debug = False):
+def GetEditedElementInterfaceReturnType(self, tagname, tree=False, debug = False):
 words = tagname.split("::")
 if words[0] == "P":
 project = self.GetProject(debug)
 if project is not None:
 pou = self.Project.getpou(words[1])
 if pou is not None:
-return self.GetPouInterfaceReturnType(pou)
+return self.GetPouInterfaceReturnType(pou, tree, debug)
 elif words[0] == 'T':
 return "BOOL"
 return None
 # Change the edited element text
 def SetEditedElementText(self, tagname, text):
 if self.Project is not None:
 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):
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
 return []
 def GetEditedElementCopy(self, tagname, debug = False):
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
-name = element.__class__.__name__
+return element.tostring()
-return element.generateXMLText(name.split("_")[-1], 0)
 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.tostring()
-text += instance_copy.generateXMLText(name.split("_")[-1], 0)
+element.remove(copy_body)
 return text
 def GenerateNewName(self, tagname, name, format, start_idx=0, exclude={}, debug=False):
 names = exclude.copy()
 if tagname is not None:
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
 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,
+if isinstance(instance,
-plcopen.commonObjects_connector,
+(PLCOpenParser.GetElementClass("step", "sfcObjects"),
-plcopen.commonObjects_continuation)):
+PLCOpenParser.GetElementClass("connector", "commonObjects"),
+PLCOpenParser.GetElementClass("continuation", "commonObjects"))):
 names[instance.getname().upper()] = True
 else:
 project = self.GetProject(debug)
 if project is not None:
 for datatype in project.getdataTypes():
 names[datatype.getname().upper()] = True
 for pou in project.getpous():
 names[pou.getname().upper()] = True
-for var in self.GetPouInterfaceVars(pou, debug):
+for var in self.GetPouInterfaceVars(pou, debug=debug):
-names[var["Name"].upper()] = True
+names[var.Name.upper()] = True
 for transition in pou.gettransitionList():
 names[transition.getname().upper()] = True
 for action in pou.getactionList():
 names[action.getname().upper()] = True
 for config in project.getconfigurations():
 i = start_idx
 while name is None or names.get(name.upper(), False):
 name = (format%i)
 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)
 if element is not None:
 # Get ids already by all the instances in edited element
 used_id = dict([(instance.getlocalId(), True) for instance in element.getinstances()])
 new_id = {}
-text = "<paste>%s</paste>"%text
+try:
+instances, error = LoadPouInstances(text.encode("utf-8"), bodytype)
+except:
+instances, error = [], ""
+if error is not None or len(instances) == 0:
+return _("Invalid plcopen element(s)!!!")
-try:
-tree = minidom.parseString(text.encode("utf-8"))
-except:
-return _("Invalid plcopen element(s)!!!")
-instances = []
 exclude = {}
-for root in tree.childNodes:
+for instance in instances:
-if root.nodeType == tree.ELEMENT_NODE and root.nodeName == "paste":
+element.addinstance(instance)
-for child in root.childNodes:
+instance_type = instance.getLocalTag()
-if child.nodeType == tree.ELEMENT_NODE:
+if instance_type == "block":
-if not child.nodeName in plcopen.ElementNameToClass:
+blocktype = instance.gettypeName()
-return _("\"%s\" element can't be pasted here!!!")%child.nodeName
+blocktype_infos = self.GetBlockType(blocktype)
+blockname = instance.getinstanceName()
-classname = plcopen.ElementNameToClass[child.nodeName]
+if blocktype_infos["type"] != "function" and blockname is not None:
-if not self.CheckPasteCompatibility[bodytype](classname):
+if element_type == "function":
-return _("\"%s\" element can't be pasted here!!!")%child.nodeName
+return _("FunctionBlock \"%s\" can't be pasted in a Function!!!")%blocktype
+blockname = self.GenerateNewName(tagname,
-classobj = getattr(plcopen, classname, None)
+blockname,
-if classobj is not None:
+"%s%%d"%blocktype,
-instance = classobj()
+debug=debug)
-instance.loadXMLTree(child)
+exclude[blockname] = True
-if child.nodeName == "block":
+instance.setinstanceName(blockname)
-blockname = instance.getinstanceName()
+self.AddEditedElementPouVar(tagname, blocktype, blockname)
-if blockname is not None:
+elif instance_type == "step":
-blocktype = instance.gettypeName()
+stepname = self.GenerateNewName(tagname,
-if element_type == "function":
+instance.getname(),
-return _("FunctionBlock \"%s\" can't be pasted in a Function!!!")%blocktype
+"Step%d",
-blockname = self.GenerateNewName(tagname,
+exclude=exclude,
-blockname,
+debug=debug)
-"%s%%d"%blocktype,
+exclude[stepname] = True
-debug=debug)
+instance.setname(stepname)
-exclude[blockname] = True
+localid = instance.getlocalId()
-instance.setinstanceName(blockname)
+if not used_id.has_key(localid):
-self.AddEditedElementPouVar(tagname, blocktype, blockname)
+new_id[localid] = True
-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)!!!")
 idx = 1
 translate_id = {}
-bbox = plcopen.rect()
+bbox = rect()
-for name, instance in instances:
+for instance in instances:
 localId = instance.getlocalId()
 bbox.union(instance.getBoundingBox())
 if used_id.has_key(localId):
 while used_id.has_key(idx) or new_id.has_key(idx):
 idx += 1
 miny *= scaling[1]
 new_pos = (max(minx, round(new_pos[0] / scaling[0]) * scaling[0]),
 max(miny, round(new_pos[1] / scaling[1]) * scaling[1]))
 else:
 new_pos = (max(30, new_pos[0]), max(30, new_pos[1]))
-diff = (new_pos[0] - x, new_pos[1] - y)
+diff = (int(new_pos[0] - x), int(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
-# Return the current pou editing informations
+def GetEditedElementInstancesInfos(self, tagname, debug = False):
-def GetEditedElementInstanceInfos(self, tagname, id = None, exclude = [], debug = False):
+element_instances = OrderedDict()
-infos = {}
-instance = None
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
-# if id is defined
+factory = BlockInstanceFactory(element_instances)
-if id is not None:
-instance = element.getinstance(id)
+pou_block_instances_xslt_tree = etree.XSLT(
-else:
+pou_block_instances_xslt,
-instance = element.getrandomInstance(exclude)
+extensions = {
-if instance is not None:
+("pou_block_instances_ns", name): getattr(factory, name)
-infos = instance.getinfos()
+for name in ["AddBlockInstance", "SetSpecificValues",
-if infos["type"] in ["input", "output", "inout"]:
+"AddInstanceConnection", "AddConnectionLink",
-var_type = self.GetEditedElementVarValueType(tagname, infos["specific_values"]["name"], debug)
+"AddLinkPoint", "AddAction"]})
-infos["specific_values"]["value_type"] = var_type
-return infos
+pou_block_instances_xslt_tree(element)
-return None
+return element_instances
 def ClearEditedElementExecutionOrder(self, tagname):
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.resetexecutionOrder()
 def ResetEditedElementExecutionOrder(self, tagname):
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.compileexecutionOrder()
-# Return the variable type of the given pou
-def GetEditedElementVarValueType(self, tagname, varname, debug = False):
-project = self.GetProject(debug)
-if 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:
-if words[0] == "T" and varname == words[2]:
-return "BOOL"
-if words[1] == varname:
-return self.GetPouInterfaceReturnType(pou)
-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()
-else:
-return vartype_content["name"]
-return None
 def SetConnectionWires(self, connection, connector):
 wires = connector.GetWires()
 idx = 0
 for wire, handle in wires:
 connection.setconnectionParameter(idx, formalParameter)
 else:
 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)
+pou.addpouLocalVar(
+self.GetVarTypeObject(var_type),
-def AddEditedElementPouExternalVar(self, tagname, type, name):
+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:
 words = tagname.split("::")
 if words[0] in ['P', 'T', 'A']:
 pou.removepouVar(type, name)
 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)
+element.addinstance(block)
-self.Project.RefreshElementUsingTree()
 def SetEditedElementBlockInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 block = element.getinstance(id)
 self.ChangeEditedElementPouVar(tagname, old_type, old_name, new_type, new_name)
 elif new_name != old_name:
 self.ChangeEditedElementPouVar(tagname, old_type, old_name, new_type, new_name)
 for param, value in infos.items():
 if param == "name":
-block.setinstanceName(value)
+if value != "":
+block.setinstanceName(value)
+else:
+block.attrib.pop("instanceName", None)
 elif param == "type":
 block.settypeName(value)
 elif param == "executionOrder" and block.getexecutionOrderId() != value:
 element.setelementExecutionOrder(block, value)
 elif param == "height":
 block.sety(value)
 elif param == "connectors":
 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)
 if connector.GetEdge() != "none":
 variable.setedge(connector.GetEdge())
 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)
 if connector.GetEdge() != "none":
 variable.setedge(connector.GetEdge())
 position = connector.GetRelPosition()
 variable.addconnectionPointOut()
 variable.connectionPointOut.setrelPositionXY(position.x, position.y)
-block.outputVariables.appendvariable(variable)
+block.tostring()
-self.Project.RefreshElementUsingTree()
+def AddEditedElementVariable(self, tagname, id, var_type):
-def AddEditedElementVariable(self, tagname, id, type):
 element = self.GetEditedElement(tagname)
 if element is not None:
-if type == INPUT:
+variable = PLCOpenParser.CreateElement(
-name = "inVariable"
+{INPUT: "inVariable",
-variable = plcopen.fbdObjects_inVariable()
+OUTPUT: "outVariable",
-elif type == OUTPUT:
+INOUT: "inOutVariable"}[var_type], "fbdObjects")
-name = "outVariable"
-variable = plcopen.fbdObjects_outVariable()
-elif type == INOUT:
-name = "inOutVariable"
-variable = plcopen.fbdObjects_inOutVariable()
 variable.setlocalId(id)
-element.addinstance(name, variable)
+element.addinstance(variable)
 def SetEditedElementVariableInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 variable = element.getinstance(id)
 if variable is None:
 return
 for param, value in infos.items():
 if param == "name":
 variable.setexpression(value)
 elif param == "executionOrder" and variable.getexecutionOrderId() != value:
 element.setelementExecutionOrder(variable, value)
 elif param == "height":
 variable.setheight(value)
 elif param == "width":
 position = input.GetRelPosition()
 variable.addconnectionPointIn()
 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:
+connection = PLCOpenParser.CreateElement(
-name = "connector"
+{CONNECTOR: "connector",
-connection = plcopen.commonObjects_connector()
+CONTINUATION: "continuation"}[connection_type], "commonObjects")
-elif type == CONTINUATION:
-name = "continuation"
-connection = plcopen.commonObjects_continuation()
 connection.setlocalId(id)
-element.addinstance(name, connection)
+element.addinstance(connection)
 def SetEditedElementConnectionInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 connection = element.getinstance(id)
 connection.setx(value)
 elif param == "y":
 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)
 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)
 if element is not None:
 comment = element.getinstance(id)
 elif param == "x":
 comment.setx(value)
 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:
+powerrail = PLCOpenParser.CreateElement(
-name = "leftPowerRail"
+{LEFTRAIL: "leftPowerRail",
-powerrail = plcopen.ldObjects_leftPowerRail()
+RIGHTRAIL: "rightPowerRail"}[powerrail_type], "ldObjects")
-elif type == RIGHTRAIL:
-name = "rightPowerRail"
-powerrail = plcopen.ldObjects_rightPowerRail()
 powerrail.setlocalId(id)
-element.addinstance(name, powerrail)
+element.addinstance(powerrail)
 def SetEditedElementPowerRailInfos(self, tagname, id, infos):
 element = self.GetEditedElement(tagname)
 if element is not None:
 powerrail = element.getinstance(id)
 elif param == "x":
 powerrail.setx(value)
 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, PLCOpenParser.GetElementClass("rightPowerRail", "ldObjects")):
-elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail):
 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)
 if element is not None:
 contact = element.getinstance(id)
 return
 for param, value in infos.items():
 if param == "name":
 contact.setvariable(value)
 elif param == "type":
-if value == CONTACT_NORMAL:
+negated, edge = {
-contact.setnegated(False)
+CONTACT_NORMAL: (False, "none"),
-contact.setedge("none")
+CONTACT_REVERSE: (True, "none"),
-elif value == CONTACT_REVERSE:
+CONTACT_RISING: (False, "rising"),
-contact.setnegated(True)
+CONTACT_FALLING: (False, "falling")}[value]
-contact.setedge("none")
+contact.setnegated(negated)
-elif value == CONTACT_RISING:
+contact.setedge(edge)
-contact.setnegated(False)
-contact.setedge("rising")
-elif value == CONTACT_FALLING:
-contact.setnegated(False)
-contact.setedge("falling")
 elif param == "height":
 contact.setheight(value)
 elif param == "width":
 contact.setwidth(value)
 elif param == "x":
 contact.connectionPointOut.setrelPositionXY(position.x, position.y)
 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)
 if element is not None:
 coil = element.getinstance(id)
 return
 for param, value in infos.items():
 if param == "name":
 coil.setvariable(value)
 elif param == "type":
-if value == COIL_NORMAL:
+negated, storage, edge = {
-coil.setnegated(False)
+COIL_NORMAL: (False, "none", "none"),
-coil.setstorage("none")
+COIL_REVERSE: (True, "none", "none"),
-coil.setedge("none")
+COIL_SET: (False, "set", "none"),
-elif value == COIL_REVERSE:
+COIL_RESET: (False, "reset", "none"),
-coil.setnegated(True)
+COIL_RISING: (False, "none", "rising"),
-coil.setstorage("none")
+COIL_FALLING: (False, "none", "falling")}[value]
-coil.setedge("none")
+coil.setnegated(negated)
-elif value == COIL_SET:
+coil.setstorage(storage)
-coil.setnegated(False)
+coil.setedge(edge)
-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")
 elif param == "height":
 coil.setheight(value)
 elif param == "width":
 coil.setwidth(value)
 elif param == "x":
 coil.connectionPointOut.setrelPositionXY(position.x, position.y)
 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)
 if element is not None:
 step = element.getinstance(id)
 step.deleteconnectionPointOutAction()
 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)
 if element is not None:
 transition = element.getinstance(id)
 position = output_connector.GetRelPosition()
 transition.addconnectionPointOut()
 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)
+self.SetConnectionWires(transition.condition.content, value)
-def AddEditedElementDivergence(self, tagname, id, type):
+def AddEditedElementDivergence(self, tagname, id, divergence_type):
 element = self.GetEditedElement(tagname)
 if element is not None:
-if type == SELECTION_DIVERGENCE:
+divergence = PLCOpenParser.CreateElement(
-name = "selectionDivergence"
+{SELECTION_DIVERGENCE: "selectionDivergence",
-divergence = plcopen.sfcObjects_selectionDivergence()
+SELECTION_CONVERGENCE: "selectionConvergence",
-elif type == SELECTION_CONVERGENCE:
+SIMULTANEOUS_DIVERGENCE: "simultaneousDivergence",
-name = "selectionConvergence"
+SIMULTANEOUS_CONVERGENCE: "simultaneousConvergence"}.get(
-divergence = plcopen.sfcObjects_selectionConvergence()
+divergence_type), "sfcObjects")
-elif type == SIMULTANEOUS_DIVERGENCE:
-name = "simultaneousDivergence"
-divergence = plcopen.sfcObjects_simultaneousDivergence()
-elif type == SIMULTANEOUS_CONVERGENCE:
-name = "simultaneousConvergence"
-divergence = plcopen.sfcObjects_simultaneousConvergence()
 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)
 if element is not None:
 divergence = element.getinstance(id)
 divergence.setx(value)
 elif param == "y":
 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)
 self.SetConnectionWires(divergence.connectionPointIn, input_connectors[0])
 else:
 divergence.setconnectionPointIn([])
 for input_connector in input_connectors:
 position = input_connector.GetRelPosition()
-if isinstance(divergence, plcopen.sfcObjects_selectionConvergence):
+connection = PLCOpenParser.CreateElement("connectionPointIn", divergence_type)
-connection = plcopen.selectionConvergence_connectionPointIn()
+divergence.appendconnectionPointIn(connection)
-else:
-connection = plcopen.connectionPointIn()
 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)
 else:
 divergence.setconnectionPointOut([])
 for output_connector in output_connectors:
 position = output_connector.GetRelPosition()
-if isinstance(divergence, plcopen.sfcObjects_selectionDivergence):
+connection = PLCOpenParser.CreateElement("connectionPointOut", divergence_type)
-connection = plcopen.selectionDivergence_connectionPointOut()
+divergence.appendconnectionPointOut(connection)
-else:
-connection = plcopen.simultaneousDivergence_connectionPointOut()
 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)
 if element is not None:
 jump = element.getinstance(id)
 self.SetConnectionWires(jump.connectionPointIn, value)
 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)
 if element is not None:
 actionBlock = element.getinstance(id)
 def RemoveEditedElementInstance(self, tagname, id):
 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 = []
 words = tagname.split("::")
 for var in self.GetConfigurationGlobalVars(words[1], debug):
-if var["Type"] == "BOOL":
+if var.Type == "BOOL":
-varlist.append(var["Name"])
+varlist.append(var.Name)
 for var in self.GetConfigurationResourceGlobalVars(words[1], words[2], debug):
-if var["Type"] == "BOOL":
+if var.Type == "BOOL":
-varlist.append(var["Name"])
+varlist.append(var.Name)
 return varlist
 def SetEditedResourceInfos(self, tagname, tasks, instances):
 resource = self.GetEditedElement(tagname)
 if resource is not None:
 resource.settask([])
 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"])
 ##                result = duration_model.match(task["Interval"]).groups()
 ##                if reduce(lambda x, y: x or y != None, result):
 if task["Triggering"] == "Cyclic":
 new_task.setinterval(task["Interval"])
 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)
 if resource is not None:
 tasks = resource.gettask()
 new_instance["Task"] = ""
 instances_data.append(new_instance)
 return tasks_data, instances_data
 def OpenXMLFile(self, filepath):
-xmlfile = open(filepath, 'r')
+self.Project, error = LoadProject(filepath)
-tree = minidom.parse(xmlfile)
+if self.Project is None:
-xmlfile.close()
+return _("Project file syntax error:\n\n") + error
+self.SetFilePath(filepath)
-self.Project = plcopen.project()
+self.CreateProjectBuffer(True)
-for child in tree.childNodes:
+self.ProgramChunks = []
-if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "project":
+self.ProgramOffset = 0
-try:
+self.NextCompiledProject = self.Copy(self.Project)
-result = self.Project.loadXMLTree(child)
+self.CurrentCompiledProject = None
-except ValueError, e:
+self.Buffering = False
-return _("Project file syntax error:\n\n") + str(e)
+self.CurrentElementEditing = None
-self.SetFilePath(filepath)
+return error
-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")
 def SaveXMLFile(self, filepath = None):
 if not filepath and self.FilePath == "":
 return False
 else:
 contentheader = {"modificationDateTime": datetime.datetime(*localtime()[:6])}
 self.Project.setcontentHeader(contentheader)
-text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+if filepath:
-extras = {"xmlns" : "http://www.plcopen.org/xml/tc6.xsd",
+SaveProject(self.Project, filepath)
-"xmlns:xhtml" : "http://www.w3.org/1999/xhtml",
+else:
-"xmlns:xsi" : "http://www.w3.org/2001/XMLSchema-instance",
+SaveProject(self.Project, self.FilePath)
-"xsi:schemaLocation" : "http://www.plcopen.org/xml/tc6.xsd"}
-text += self.Project.generateXMLText("project", 0, extras)
-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)
 return True
 """
 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
 def IsProjectBufferEnabled(self):
 current_saved = self.ProjectBuffer.IsCurrentSaved()
 self.CreateProjectBuffer(current_saved)
 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
 def StartBuffering(self):
 if self.ProjectBuffer is not None:
 else:
 self.ProjectSaved = False
 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):
 self.EndBuffering()
 if self.ProjectBuffer is not None:
 return self.ProjectSaved
 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:
 first = self.ProjectBuffer.IsFirst() and not self.Buffering
 last = self.ProjectBuffer.IsLast()

branch	1.1 Korean release
changeset 1384	02fe382c4511
parent 1373	4278d5c1e414
child 1378	cbc0f64a25eb