--- a/IDEFrame.py Wed Sep 04 00:06:44 2013 +0200
+++ b/IDEFrame.py Mon Sep 09 00:48:34 2013 +0200
@@ -2302,7 +2302,6 @@
if tagname is not None:
self._Refresh(TITLE, FILEMENU, EDITMENU, PROJECTTREE, POUINSTANCEVARIABLESPANEL)
self.EditProjectElement(ITEM_CONFIGURATION, tagname)
- dialog.Destroy()
def GenerateAddResourceFunction(self, config_name):
def OnAddResourceMenu(event):
--- a/PLCControler.py Wed Sep 04 00:06:44 2013 +0200
+++ b/PLCControler.py Mon Sep 09 00:48:34 2013 +0200
@@ -24,13 +24,12 @@
from xml.dom import minidom
from types import StringType, UnicodeType, TupleType
-import cPickle
+from copy import deepcopy
import os,sys,re
import datetime
from time import localtime
-from plcopen import plcopen
-from plcopen.structures import *
+from plcopen import*
from graphics.GraphicCommons import *
from PLCGenerator import *
@@ -66,14 +65,14 @@
ITEM_VAR_INOUT
] = range(17, 24)
-VAR_CLASS_INFOS = {"Local" : (plcopen.interface_localVars, ITEM_VAR_LOCAL),
- "Global" : (plcopen.interface_globalVars, ITEM_VAR_GLOBAL),
- "External" : (plcopen.interface_externalVars, ITEM_VAR_EXTERNAL),
- "Temp" : (plcopen.interface_tempVars, ITEM_VAR_TEMP),
- "Input" : (plcopen.interface_inputVars, ITEM_VAR_INPUT),
- "Output" : (plcopen.interface_outputVars, ITEM_VAR_OUTPUT),
- "InOut" : (plcopen.interface_inOutVars, ITEM_VAR_INOUT)
- }
+VAR_CLASS_INFOS = {
+ "Local": ("localVars", ITEM_VAR_LOCAL),
+ "Global": ("globalVars", ITEM_VAR_GLOBAL),
+ "External": ("externalVars", ITEM_VAR_EXTERNAL),
+ "Temp": ("tempVars", ITEM_VAR_TEMP),
+ "Input": ("inputVars", ITEM_VAR_INPUT),
+ "Output": ("outputVars", ITEM_VAR_OUTPUT),
+ "InOut": ("inOutVars", ITEM_VAR_INOUT)}
POU_TYPES = {"program": ITEM_PROGRAM,
"functionBlock": ITEM_FUNCTIONBLOCK,
@@ -215,7 +214,7 @@
self.ProgramFilePath = ""
def GetQualifierTypes(self):
- return plcopen.QualifierList
+ return QualifierList
def GetProject(self, debug = False):
if debug and self.CurrentCompiledProject is not None:
@@ -234,11 +233,12 @@
# Create a new project by replacing the current one
def CreateNewProject(self, properties):
# Create the project
- self.Project = plcopen.project()
+ self.Project = PLCOpenParser.CreateRoot()
properties["creationDateTime"] = datetime.datetime(*localtime()[:6])
self.Project.setfileHeader(properties)
self.Project.setcontentHeader(properties)
self.SetFilePath("")
+
# Initialize the project buffer
self.CreateProjectBuffer(False)
self.ProgramChunks = []
@@ -390,8 +390,9 @@
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()
+ vartype_content_type = vartype_content.getLocalTag()
+ if vartype_content_type == "derived":
+ var_type = vartype_content.getname()
pou_type = None
pou = project.getpou(var_type)
if pou is not None:
@@ -419,15 +420,15 @@
"class": var_class,
"edit": False,
"debug": False}
- elif vartype_content["name"] in ["string", "wstring"]:
+ elif vartype_content_type in ["string", "wstring"]:
return {"name": variable.getname(),
- "type": vartype_content["name"].upper(),
+ "type": vartype_content_type.upper(),
"class": var_class,
"edit": False,
"debug": True}
else:
return {"name": variable.getname(),
- "type": vartype_content["name"],
+ "type": vartype_content_type,
"class": var_class,
"edit": False,
"debug": True}
@@ -556,14 +557,14 @@
for varlist in varlists:
for variable in varlist.getvariable():
vartype_content = variable.gettype().getcontent()
- if vartype_content["name"] == "derived":
+ if vartype_content.getLocalTag() == "derived":
var_path = "%s.%s" % (parent_path, variable.getname())
- var_type = vartype_content["value"].getname()
+ var_type = vartype_content.getname()
if var_type == pou_type:
instances.append(var_path)
else:
pou = project.getpou(var_type)
- if pou is not None and project.ElementIsUsedBy(pou_type, var_type):
+ if pou is not None:# and project.ElementIsUsedBy(pou_type, var_type):
instances.extend(
self.RecursiveSearchPouInstances(
project, pou_type, var_path,
@@ -598,7 +599,7 @@
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):
+ if pou is not None:# and project.ElementIsUsedBy(words[1], pou_type):
instances.extend(
self.RecursiveSearchPouInstances(
project, words[1], pou_path,
@@ -625,7 +626,7 @@
for variable in varlist.getvariable():
if variable.getname() == parts[0]:
vartype_content = variable.gettype().getcontent()
- if vartype_content["name"] == "derived":
+ if vartype_content.getLocalTag() == "derived":
return self.RecursiveGetPouInstanceTagName(
project,
vartype_content["value"].getname(),
@@ -656,14 +657,14 @@
for variable in varlist.getvariable():
if variable.getname() == parts[0]:
vartype_content = variable.gettype().getcontent()
- if vartype_content["name"] == "derived":
+ if vartype_content.getLocalTag() == "derived":
if len(parts) == 1:
return self.ComputePouName(
- vartype_content["value"].getname())
+ vartype_content.getname())
else:
return self.RecursiveGetPouInstanceTagName(
project,
- vartype_content["value"].getname(),
+ vartype_content.getname(),
parts[1:], debug)
return None
@@ -728,23 +729,23 @@
# 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)
+ #project = self.GetProject(debug)
+ #if project is not None:
+ # return project.ElementIsUsed(name)
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)
+ #project = self.GetProject(debug)
+ #if project is not None:
+ # return project.ElementIsUsed(name)
return False
# Return if pou given by name is directly or undirectly used by the reference pou
def PouIsUsedBy(self, name, reference, debug = False):
- project = self.GetProject(debug)
- if project is not None:
- return project.ElementIsUsedBy(name, reference)
+ #project = self.GetProject(debug)
+ #if project is not None:
+ # return project.ElementIsUsedBy(name, reference)
return False
def GenerateProgram(self, filepath=None):
@@ -832,14 +833,13 @@
pou = self.Project.getpou(name)
if pou is not None:
pou.setpouType(pou_type)
- self.Project.RefreshCustomBlockTypes()
self.BufferProject()
def GetPouXml(self, pou_name):
if self.Project is not None:
pou = self.Project.getpou(pou_name)
if pou is not None:
- return pou.generateXMLText('pou', 0)
+ return pou.tostring()
return None
def PastePou(self, pou_type, pou_xml):
@@ -847,47 +847,40 @@
Adds the POU defined by 'pou_xml' to the current project with type 'pou_type'
'''
try:
- tree = minidom.parseString(pou_xml.encode("utf-8"))
- root = tree.childNodes[0]
+ new_pou = LoadPou(pou_xml)
except:
return _("Couldn't paste non-POU object.")
-
- if root.nodeName == "pou":
- new_pou = plcopen.pous_pou()
- new_pou.loadXMLTree(root)
-
- name = new_pou.getname()
+
+ name = new_pou.getname()
+
+ idx = 0
+ new_name = name
+ while self.Project.getpou(new_name):
+ # a POU with that name already exists.
+ # make a new name and test if a POU with that name exists.
+ # append an incrementing numeric suffix to the POU name.
+ idx += 1
+ new_name = "%s%d" % (name, idx)
- idx = 0
- new_name = name
- while self.Project.getpou(new_name):
- # a POU with that name already exists.
- # make a new name and test if a POU with that name exists.
- # append an incrementing numeric suffix to the POU name.
- idx += 1
- new_name = "%s%d" % (name, idx)
-
- # we've found a name that does not already exist, use it
- new_pou.setname(new_name)
+ # we've found a name that does not already exist, use it
+ new_pou.setname(new_name)
+
+ if pou_type is not None:
+ orig_type = new_pou.getpouType()
+
+ # prevent violations of POU content restrictions:
+ # function blocks cannot be pasted as functions,
+ # programs cannot be pasted as functions or function blocks
+ if orig_type == 'functionBlock' and pou_type == 'function' or \
+ orig_type == 'program' and pou_type in ['function', 'functionBlock']:
+ return _('''%s "%s" can't be pasted as a %s.''') % (orig_type, name, pou_type)
- if pou_type is not None:
- orig_type = new_pou.getpouType()
-
- # prevent violations of POU content restrictions:
- # function blocks cannot be pasted as functions,
- # programs cannot be pasted as functions or function blocks
- if orig_type == 'functionBlock' and pou_type == 'function' or \
- orig_type == 'program' and pou_type in ['function', 'functionBlock']:
- return _('''%s "%s" can't be pasted as a %s.''') % (orig_type, name, pou_type)
-
- new_pou.setpouType(pou_type)
-
- self.Project.insertpou(-1, new_pou)
- self.BufferProject()
-
- return self.ComputePouName(new_name),
- else:
- return _("Couldn't paste non-POU object.")
+ new_pou.setpouType(pou_type)
+
+ self.Project.insertpou(-1, new_pou)
+ self.BufferProject()
+
+ return self.ComputePouName(new_name),
# Remove a Pou from project
def ProjectRemovePou(self, pou_name):
@@ -982,8 +975,6 @@
if datatype is not None:
datatype.setname(new_name)
self.Project.updateElementName(old_name, new_name)
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshDataTypeHierarchy()
self.BufferProject()
# Change the name of a pou
@@ -994,8 +985,6 @@
if pou is not None:
pou.setname(new_name)
self.Project.updateElementName(old_name, new_name)
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshCustomBlockTypes()
self.BufferProject()
# Change the name of a pou transition
@@ -1032,7 +1021,6 @@
for var in varlist.getvariable():
if var.getname() == old_name:
var.setname(new_name)
- self.Project.RefreshCustomBlockTypes()
self.BufferProject()
# Change the name of a configuration
@@ -1071,7 +1059,6 @@
pou = project.getpou(name)
if pou is not None:
pou.setdescription(description)
- project.RefreshCustomBlockTypes()
self.BufferProject()
# Return the type of the pou given by its name
@@ -1170,9 +1157,9 @@
current_type = next_type
infos = VAR_CLASS_INFOS.get(var["Class"], None)
if infos is not None:
- current_varlist = infos[0]()
+ current_varlist = PLCOpenParser.CreateElement(infos[0], "interface")
else:
- current_varlist = plcopen.varList()
+ current_varlist = PLCOpenParser.CreateElement("varList")
varlist_list.append((var["Class"], current_varlist))
if var["Option"] == "Constant":
current_varlist.setconstant(True)
@@ -1181,49 +1168,47 @@
elif var["Option"] == "Non-Retain":
current_varlist.setnonretain(True)
# Create variable and change its properties
- tempvar = plcopen.varListPlain_variable()
+ tempvar = PLCOpenParser.CreateElement("variable", "varListPlain")
tempvar.setname(var["Name"])
- var_type = plcopen.dataType()
+ var_type = PLCOpenParser.CreateElement("type", "variable")
if isinstance(var["Type"], TupleType):
if var["Type"][0] == "array":
array_type, base_type_name, dimensions = var["Type"]
- array = plcopen.derivedTypes_array()
+ array = PLCOpenParser.CreateElement("array", "dataType")
+ baseType = PLCOpenParser.CreateElement("baseType", "array")
+ array.setbaseType(baseType)
for i, dimension in enumerate(dimensions):
- dimension_range = plcopen.rangeSigned()
- dimension_range.setlower(dimension[0])
- dimension_range.setupper(dimension[1])
+ dimension_range = PLCOpenParser.CreateElement("dimension", "array")
if i == 0:
array.setdimension([dimension_range])
else:
array.appenddimension(dimension_range)
+ dimension_range.setlower(dimension[0])
+ dimension_range.setupper(dimension[1])
if base_type_name in self.GetBaseTypes():
- if base_type_name == "STRING":
- array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif base_type_name == "WSTRING":
- array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
- else:
- array.baseType.setcontent({"name" : base_type_name, "value" : None})
+ baseType.setcontent(PLCOpenParser.CreateElement(
+ base_type_name.lower()
+ if base_type_name in ["STRING", "WSTRING"]
+ else base_type_name, "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(base_type_name)
- array.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
- var_type.setcontent({"name" : "array", "value" : array})
+ baseType.setcontent(derived_datatype)
+ var_type.setcontent(array)
elif var["Type"] in self.GetBaseTypes():
- if var["Type"] == "STRING":
- var_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif var["Type"] == "WSTRING":
- var_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
- else:
- var_type.setcontent({"name" : var["Type"], "value" : None})
+ var_type.setcontent(PLCOpenParser.CreateElement(
+ var["Type"].lower()
+ if var["Type"] in ["STRING", "WSTRING"]
+ else var["Type"], "dataType"))
else:
- derived_type = plcopen.derivedTypes_derived()
+ derived_type = PLCOpenParser.CreateElement("derived", "dataType")
derived_type.setname(var["Type"])
- var_type.setcontent({"name" : "derived", "value" : derived_type})
+ var_type.setcontent(derived_type)
tempvar.settype(var_type)
if var["Initial Value"] != "":
- value = plcopen.value()
+ value = PLCOpenParser.CreateElement("initialValue", "variable")
value.setvalue(var["Initial Value"])
tempvar.setinitialValue(value)
if var["Location"] != "":
@@ -1231,8 +1216,8 @@
else:
tempvar.setaddress(None)
if var['Documentation'] != "":
- ft = plcopen.formattedText()
- ft.settext(var['Documentation'])
+ ft = PLCOpenParser.CreateElement("documentation", "variable")
+ ft.setanyText(var['Documentation'])
tempvar.setdocumentation(ft)
# Add variable to varList
@@ -1248,27 +1233,27 @@
tempvar = {"Name": var.getname()}
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- tempvar["Type"] = vartype_content["value"].getname()
- elif vartype_content["name"] == "array":
+ vartype_content_type = vartype_content.getLocalTag()
+ if vartype_content_type == "derived":
+ tempvar["Type"] = vartype_content.getname()
+ elif vartype_content_type == "array":
dimensions = []
- for dimension in vartype_content["value"].getdimension():
+ for dimension in vartype_content.getdimension():
dimensions.append((dimension.getlower(), dimension.getupper()))
- base_type = vartype_content["value"].baseType.getcontent()
- if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
- base_type_name = base_type["name"].upper()
+ base_type = vartype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
+ if base_type_type == "derived":
+ base_type_name = base_type.getname()
else:
- base_type_name = base_type["value"].getname()
+ base_type_name = base_type_type.upper()
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["Type"] = vartype_content_type.upper()
+
tempvar["Edit"] = True
-
+
initial = var.getinitialValue()
- if initial:
+ if initial is not None:
tempvar["Initial Value"] = initial.getvalue()
else:
tempvar["Initial Value"] = ""
@@ -1289,8 +1274,8 @@
tempvar["Option"] = ""
doc = var.getdocumentation()
- if doc:
- tempvar["Documentation"] = doc.gettext()
+ if doc is not None:
+ tempvar["Documentation"] = doc.getanyText()
else:
tempvar["Documentation"] = ""
@@ -1313,9 +1298,9 @@
configuration = self.Project.getconfiguration(name)
if configuration is not None:
# Set configuration global vars
- configuration.setglobalVars([])
- for vartype, varlist in self.ExtractVarLists(vars):
- configuration.globalVars.append(varlist)
+ configuration.setglobalVars([
+ varlist for vartype, varlist
+ in self.ExtractVarLists(vars)])
# Return the configuration globalvars
def GetConfigurationGlobalVars(self, name, debug = False):
@@ -1354,9 +1339,9 @@
resource = self.Project.getconfigurationResource(config_name, name)
# Set resource global vars
if resource is not None:
- resource.setglobalVars([])
- for vartype, varlist in self.ExtractVarLists(vars):
- resource.globalVars.append(varlist)
+ resource.setglobalVars([
+ varlist for vartype, varlist
+ in self.ExtractVarLists(vars)])
# Return the resource globalvars
def GetConfigurationResourceGlobalVars(self, config_name, name, debug = False):
@@ -1365,7 +1350,7 @@
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
for varlist in resource.getglobalVars():
for var in varlist.getvariable():
@@ -1409,31 +1394,31 @@
if not en:
tree.insert(0, ("EN", "BOOL", ([], [])))
return tree, []
- datatype = project.getdataType(typename)
- if datatype is None:
- datatype = self.GetConfNodeDataType(typename)
+ datatype = self.GetDataType(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":
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type == "derived":
+ return self.GenerateVarTree(basetype_content.getname())
+ elif basetype_content_type == "array":
dimensions = []
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["name"] == "derived":
- tree = self.GenerateVarTree(base_type["value"].getname())
+ base_type = basetype_content.baseType.getcontent()
+ if base_type.getLocalTag() == "derived":
+ tree = self.GenerateVarTree(base_type.getname())
if len(tree[1]) == 0:
tree = tree[0]
- for dimension in basetype_content["value"].getdimension():
+ for dimension in basetype_content.getdimension():
dimensions.append((dimension.getlower(), dimension.getupper()))
return tree, dimensions
- elif basetype_content["name"] == "struct":
- for element in basetype_content["value"].getvariable():
+ elif basetype_content_type == "struct":
+ for element in basetype_content.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())))
+ element_type_type = element_type.getLocalTag()
+ if element_type_type == "derived":
+ tree.append((element.getname(), element_type.getname(), self.GenerateVarTree(element_type.getname())))
else:
- tree.append((element.getname(), element_type["name"], ([], [])))
+ tree.append((element.getname(), element_type_type, ([], [])))
return tree, []
return [], []
@@ -1451,7 +1436,7 @@
tempvar["Tree"] = ([], [])
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
+ if vartype_content.getLocalTag() == "derived":
tempvar["Edit"] = not pou.hasblock(tempvar["Name"])
tempvar["Tree"] = self.GenerateVarTree(tempvar["Type"], debug)
@@ -1465,46 +1450,40 @@
pou = self.Project.getpou(name)
if pou is not None:
if pou.interface is None:
- pou.interface = plcopen.pou_interface()
+ pou.interface = PLCOpenParser.CreateElement("interface", "pou")
# Set Pou interface
- pou.setvars(self.ExtractVarLists(vars))
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshCustomBlockTypes()
-
+ pou.setvars([varlist for varlist_type, varlist in self.ExtractVarLists(vars)])
+
# Replace the return type of the pou given by its name (only for functions)
- def SetPouInterfaceReturnType(self, name, type):
+ def SetPouInterfaceReturnType(self, name, return_type):
if self.Project is not None:
pou = self.Project.getpou(name)
if pou is not None:
if pou.interface is None:
- pou.interface = plcopen.pou_interface()
+ pou.interface = PLCOpenParser.CreateElement("interface", "pou")
# If there isn't any return type yet, add it
- return_type = pou.interface.getreturnType()
- if not return_type:
- return_type = plcopen.dataType()
- pou.interface.setreturnType(return_type)
+ return_type_obj = pou.interface.getreturnType()
+ if return_type_obj is None:
+ return_type_obj = PLCOpenParser.CreateElement("returnType", "interface")
+ pou.interface.setreturnType(return_type_obj)
# Change return type
- if type in self.GetBaseTypes():
- if type == "STRING":
- return_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif type == "WSTRING":
- return_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
- else:
- return_type.setcontent({"name" : type, "value" : None})
+ if return_type in self.GetBaseTypes():
+ return_type_obj.setcontent(PLCOpenParser.CreateElement(
+ return_type.lower()
+ if return_type in ["STRING", "WSTRING"]
+ else return_type, "dataType"))
else:
- derived_type = plcopen.derivedTypes_derived()
- derived_type.setname(type)
- return_type.setcontent({"name" : "derived", "value" : derived_type})
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshCustomBlockTypes()
-
+ derived_type = PLCOpenParser.CreateElement("derived", "dataType")
+ derived_type.setname(return_type)
+ return_type.setcontent(derived_type)
+
def UpdateProjectUsedPous(self, old_name, new_name):
- if self.Project:
+ if self.Project is not None:
self.Project.updateElementName(old_name, new_name)
def UpdateEditedElementUsedVariable(self, tagname, old_name, new_name):
pou = self.GetEditedElement(tagname)
- if pou:
+ if pou is not None:
pou.updateElementName(old_name, new_name)
# Return the return type of the pou given by its name
@@ -1523,21 +1502,21 @@
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()
- if returntype_content["name"] == "derived":
- return returntype_content["value"].getname()
- elif returntype_content["name"] in ["string", "wstring"]:
- return returntype_content["name"].upper()
+ returntype_content_type = returntype_content.getLocalTag()
+ if returntype_content_type == "derived":
+ return returntype_content.getname()
else:
- return returntype_content["name"]
+ return returntype_content_type.upper()
return None
# Function that add a new confnode to the confnode list
def AddConfNodeTypesList(self, typeslist):
self.ConfNodeTypes.extend(typeslist)
addedcat = [{"name": _("%s POUs") % confnodetypes["name"],
- "list": confnodetypes["types"].GetCustomBlockTypes()}
+ "list": [pou.getblockInfos()
+ for pou in confnodetypes["types"].getpous()]}
for confnodetypes in typeslist]
self.TotalTypes.extend(addedcat)
for cat in addedcat:
@@ -1551,23 +1530,14 @@
self.TotalTypesDict = StdBlckDct.copy()
self.TotalTypes = StdBlckLst[:]
- def GetConfNodeBlockTypes(self):
- return [{"name": _("%s POUs") % confnodetypes["name"],
- "list": confnodetypes["types"].GetCustomBlockTypes()}
- for confnodetypes in self.ConfNodeTypes]
-
def GetConfNodeDataTypes(self, exclude = None, only_locatables = False):
return [{"name": _("%s Data Types") % confnodetypes["name"],
- "list": [datatype["name"] for datatype in confnodetypes["types"].GetCustomDataTypes(exclude, only_locatables)]}
+ "list": [
+ datatype.getname()
+ for datatype in confnodetypes["types"].getdataTypes()
+ if not only_locatables or self.IsLocatableDataType(datatype, debug)]}
for confnodetypes in self.ConfNodeTypes]
- def GetConfNodeDataType(self, typename):
- for confnodetype in self.ConfNodeTypes:
- datatype = confnodetype["types"].getdataType(typename)
- if datatype is not None:
- return datatype
- return None
-
def GetVariableLocationTree(self):
return []
@@ -1577,25 +1547,23 @@
def GetConfigurationExtraVariables(self):
global_vars = []
for var_name, var_type, var_initial in self.GetConfNodeGlobalInstances():
- tempvar = plcopen.varListPlain_variable()
+ tempvar = PLCOpenParser.CreateElement("variable", "globalVars")
tempvar.setname(var_name)
- tempvartype = plcopen.dataType()
+ tempvartype = PLCOpenParser.CreateElement("dataType", "variable")
if var_type in self.GetBaseTypes():
- if var_type == "STRING":
- tempvartype.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif var_type == "WSTRING":
- tempvartype.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
- else:
- tempvartype.setcontent({"name" : var_type, "value" : None})
+ tempvar.setcontent(PLCOpenParser.CreateElement(
+ var_type.lower()
+ if var_type in ["STRING", "WSTRING"]
+ else var_type, "dataType"))
else:
- tempderivedtype = plcopen.derivedTypes_derived()
+ tempderivedtype = PLCOpenParser.CreateElement("derived", "dataType")
tempderivedtype.setname(var_type)
- tempvartype.setcontent({"name" : "derived", "value" : tempderivedtype})
+ tempvartype.setcontent(tempderivedtype)
tempvar.settype(tempvartype)
if var_initial != "":
- value = plcopen.value()
+ value = PLCOpenParser.CreateElement("initialValue", "variable")
value.setvalue(var_initial)
tempvar.setinitialValue(value)
@@ -1623,7 +1591,16 @@
return result_blocktype
project = self.GetProject(debug)
if project is not None:
- return project.GetCustomBlockType(typename, inputs)
+ blocktype = project.getpou(typename)
+ if blocktype is not None:
+ blocktype_infos = blocktype.getblockInfos()
+ if inputs in [None, "undefined"]:
+ return blocktype_infos
+
+ if inputs == tuple([var_type
+ for name, var_type, modifier in blocktype_infos["inputs"]]):
+ return blocktype_infos
+
return None
# Return Block types checking for recursion
@@ -1635,22 +1612,19 @@
if project is not None:
pou_type = None
if words[0] in ["P","T","A"]:
- blocktypes = []
name = words[1]
pou_type = self.GetPouType(name, debug)
- if pou_type == "function":
- for category in self.TotalTypes:
- cat = {"name" : category["name"], "list" : []}
- for block in category["list"]:
- if block["type"] == "function":
- cat["list"].append(block)
- if len(cat["list"]) > 0:
- blocktypes.append(cat)
- else:
- blocktypes = [category for category in self.TotalTypes]
+ filter = (["function"]
+ if pou_type == "function" or words[0] == "T"
+ else ["functionBlock", "function"])
+ blocktypes = [
+ {"name": category["name"],
+ "list": [block for block in category["list"]
+ if block["type"] in filter]}
+ for category in self.TotalTypes]
blocktypes.append({"name" : USER_DEFINED_POUS,
- "list": project.GetCustomBlockTypes(name,
- pou_type == "function" or words[0] == "T")})
+ "list": [pou.getblockInfos()
+ for pou in project.getpous(name, filter)]})
return blocktypes
return self.TotalTypes
@@ -1663,11 +1637,11 @@
blocktypes.append(block["name"])
project = self.GetProject(debug)
if project is not None:
- name = ""
words = tagname.split("::")
- if words[0] in ["P","T","A"]:
- name = words[1]
- blocktypes.extend(project.GetCustomFunctionBlockTypes(name))
+ blocktypes.extend([pou.getname()
+ for pou in project.getpous(
+ words[1] if words[0] in ["P","T","A"] else None,
+ ["functionBlock"])])
return blocktypes
# Return Block types checking for recursion
@@ -1679,7 +1653,9 @@
blocktypes.append(blocktype["name"])
project = self.GetProject(debug)
if project is not None:
- blocktypes.extend(project.GetCustomBlockResource())
+ blocktypes.extend(
+ [pou.getblockInfos()
+ for pou in project.getpous(filter=["program"])])
return blocktypes
# Return Data Types checking for recursion
@@ -1694,25 +1670,55 @@
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)])
if confnodetypes:
for category in self.GetConfNodeDataTypes(name, only_locatables):
datatypes.extend(category["list"])
return datatypes
- # Return Base Type of given possible derived type
- def GetBaseType(self, type, debug = False):
- project = self.GetProject(debug)
- if project is not None:
- result = project.GetBaseType(type)
+ # Return Data Type Object
+ def 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"].GetBaseType(type)
+ result = confnodetype["types"].getdataType(typename)
if result is not None:
return result
return None
+ # Return Data Type Object Base Type
+ def GetDataTypeBaseType(self, datatype):
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type in ["array", "subrangeSigned", "subrangeUnsigned"]:
+ basetype = basetype_content.baseType.getcontent()
+ basetype_type = basetype.getLocalTag()
+ return (basetype.getname() if basetype_type == "derived"
+ else basetype_type.upper())
+ elif basetype_content_type == "derived":
+ return basetype_content_type.getname()
+ return None
+
+ # Return Base Type of given possible derived type
+ def GetBaseType(self, typename, debug = False):
+ if TypeHierarchy.has_key(typename):
+ return typename
+
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype = self.GetDataTypeBaseType(datatype)
+ if basetype is not None:
+ return self.GetBaseType(basetype, debug)
+ return typename
+
+ return None
+
def GetBaseTypes(self):
'''
return the list of datatypes defined in IEC 61131-3.
@@ -1721,93 +1727,131 @@
'''
return [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]
- def IsOfType(self, type, reference, debug = False):
- if reference is None:
+ def IsOfType(self, typename, reference, debug = False):
+ if reference is None or typename == reference:
return True
- elif type == reference:
- return True
- elif type in TypeHierarchy:
- return self.IsOfType(TypeHierarchy[type], reference)
- else:
- project = self.GetProject(debug)
- if project is not None and project.IsOfType(type, reference):
- return True
- for confnodetype in self.ConfNodeTypes:
- if confnodetype["types"].IsOfType(type, reference):
- return True
+
+ basetype = TypeHierarchy.get(typename)
+ if basetype is not None:
+ return self.IsOfType(basetype, reference)
+
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype = self.GetDataTypeBaseType(datatype)
+ if basetype is not None:
+ return self.IsOfType(basetype, reference, debug)
+
return False
- def IsEndType(self, type):
- if type is not None:
- return not type.startswith("ANY")
+ def IsEndType(self, typename):
+ if typename is not None:
+ return not typename.startswith("ANY")
return True
- def IsLocatableType(self, type, debug = False):
- if isinstance(type, TupleType):
- return False
- if self.GetBlockType(type) is not None:
+ def IsLocatableDataType(self, datatype, debug = False):
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type in ["enum", "struct"]:
return False
- project = self.GetProject(debug)
- if project is not None:
- datatype = project.getdataType(type)
- if datatype is None:
- datatype = self.GetConfNodeDataType(type)
- if datatype is not None:
- return project.IsLocatableType(datatype)
+ elif basetype_content_type == "derived":
+ return self.IsLocatableType(basetype_content.getname())
+ elif basetype_content_name == "array":
+ array_base_type = basetype_content.baseType.getcontent()
+ if array_base_type.getLocalTag() == "derived":
+ return self.IsLocatableType(array_base_type.getname(), debug)
return True
-
- def IsEnumeratedType(self, type, debug = False):
- project = self.GetProject(debug)
- if project is not None:
- datatype = project.getdataType(type)
- if datatype is None:
- datatype = self.GetConfNodeDataType(type)
- if datatype is not None:
- basetype_content = datatype.baseType.getcontent()
- return basetype_content["name"] == "enum"
+
+ def IsLocatableType(self, typename, debug = False):
+ if isinstance(typename, TupleType) or self.GetBlockType(typename) is not None:
+ return False
+
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ return self.IsLocatableDataType(datatype)
+ return True
+
+ def IsEnumeratedType(self, typename, debug = False):
+ if isinstance(typename, TupleType):
+ typename = typename[1]
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type == "derived":
+ return self.IsEnumeratedType(basetype_content_type, debug)
+ return basetype_content_type == "enum"
return False
- def IsNumType(self, type, debug = False):
- return self.IsOfType(type, "ANY_NUM", debug) or\
- self.IsOfType(type, "ANY_BIT", debug)
+ def IsSubrangeType(self, typename, exclude=None, debug = False):
+ if typename == exclude:
+ return False
+ if isinstance(typename, TupleType):
+ typename = typename[1]
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type == "derived":
+ return self.IsSubrangeType(basetype_content_type, exclude, debug)
+ elif basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
+ return not self.IsOfType(
+ self.GetDataTypeBaseType(datatype), exclude)
+ return False
+
+ def IsNumType(self, typename, debug = False):
+ return self.IsOfType(typename, "ANY_NUM", debug) or\
+ self.IsOfType(typename, "ANY_BIT", debug)
- def GetDataTypeRange(self, type, debug = False):
- if type in DataTypeRange:
- return DataTypeRange[type]
+ def GetDataTypeRange(self, typename, debug = False):
+ range = DataTypeRange.get(typename)
+ if range is not None:
+ return range
+ datatype = self.GetDataType(typename, debug)
+ if datatype is not None:
+ basetype_content = datatype.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
+ return (basetype_content.range.getlower(),
+ basetype_content.range.getupper())
+ elif basetype_content_type == "derived":
+ return self.GetDataTypeRange(basetype_content.getname(), debug)
+ return None
+
+ # Return Subrange types
+ def GetSubrangeBaseTypes(self, exclude, debug = False):
+ subrange_basetypes = DataTypeRange.keys()
+ project = self.GetProject(debug)
+ if project is not None:
+ subrange_basetypes.extend(
+ [datatype.getname() for datatype in project.getdataTypes()
+ if self.IsSubrangeType(datatype.getname(), exclude, debug)])
+ for confnodetype in self.ConfNodeTypes:
+ subrange_basetypes.extend(
+ [datatype.getname() for datatype in confnodetype["types"].getdataTypes()
+ if self.IsSubrangeType(datatype.getname(), exclude, debug)])
+ return subrange_basetypes
+
+ # Return Enumerated Values
+ def GetEnumeratedDataValues(self, typename = None, debug = False):
+ values = []
+ if typename is not None:
+ datatype_obj = self.GetDataType(typename, debug)
+ if datatype_obj is not None:
+ basetype_content = datatype_obj.baseType.getcontent()
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type == "enum":
+ return [value.getname()
+ for value in basetype_content.xpath(
+ "ppx:values/ppx:value",
+ namespaces=PLCOpenParser.NSMAP)]
+ elif basetype_content_type == "derived":
+ return self.GetEnumeratedDataValues(basetype_content.getname(), debug)
else:
project = self.GetProject(debug)
if project is not None:
- result = project.GetDataTypeRange(type)
- if result is not None:
- return result
+ values.extend(project.GetEnumeratedDataTypeValues())
for confnodetype in self.ConfNodeTypes:
- result = confnodetype["types"].GetDataTypeRange(type)
- if result is not None:
- return result
- return None
-
- # Return Subrange types
- def GetSubrangeBaseTypes(self, exclude, debug = False):
- subrange_basetypes = []
- project = self.GetProject(debug)
- if project is not None:
- subrange_basetypes.extend(project.GetSubrangeBaseTypes(exclude))
- for confnodetype in self.ConfNodeTypes:
- subrange_basetypes.extend(confnodetype["types"].GetSubrangeBaseTypes(exclude))
- return DataTypeRange.keys() + subrange_basetypes
-
- # Return Enumerated Values
- def GetEnumeratedDataValues(self, type = None, debug = False):
- values = []
- project = self.GetProject(debug)
- if project is not None:
- values.extend(project.GetEnumeratedDataTypeValues(type))
- if type is None and len(values) > 0:
- return values
- for confnodetype in self.ConfNodeTypes:
- values.extend(confnodetype["types"].GetEnumeratedDataTypeValues(type))
- if type is None and len(values) > 0:
- return values
+ values.extend(confnodetype["types"].GetEnumeratedDataTypeValues())
return values
#-------------------------------------------------------------------------------
@@ -1859,62 +1903,64 @@
if datatype is None:
return None
basetype_content = datatype.baseType.getcontent()
- if basetype_content["value"] is None or basetype_content["name"] in ["string", "wstring"]:
- infos["type"] = "Directly"
- infos["base_type"] = basetype_content["name"].upper()
- elif basetype_content["name"] == "derived":
- infos["type"] = "Directly"
- infos["base_type"] = basetype_content["value"].getname()
- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
+ basetype_content_type = basetype_content.getLocalTag()
+ if basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
infos["type"] = "Subrange"
- infos["min"] = basetype_content["value"].range.getlower()
- infos["max"] = basetype_content["value"].range.getupper()
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["value"] is None:
- infos["base_type"] = base_type["name"]
- else:
- infos["base_type"] = base_type["value"].getname()
- elif basetype_content["name"] == "enum":
+ infos["min"] = basetype_content.range.getlower()
+ infos["max"] = basetype_content.range.getupper()
+ base_type = basetype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
+ infos["base_type"] = (base_type.getname()
+ if base_type_type == "derived"
+ else base_type_type)
+ elif basetype_content_type == "enum":
infos["type"] = "Enumerated"
infos["values"] = []
- for value in basetype_content["value"].values.getvalue():
+ for value in basetype_content.xpath("ppx:values/ppx:value", namespaces=PLCOpenParser.NSMAP):
infos["values"].append(value.getname())
- elif basetype_content["name"] == "array":
+ elif basetype_content_type == "array":
infos["type"] = "Array"
infos["dimensions"] = []
- for dimension in basetype_content["value"].getdimension():
+ for dimension in basetype_content.getdimension():
infos["dimensions"].append((dimension.getlower(), dimension.getupper()))
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
- infos["base_type"] = base_type["name"].upper()
- else:
- infos["base_type"] = base_type["value"].getname()
- elif basetype_content["name"] == "struct":
+ base_type = basetype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
+ infos["base_type"] = (base_type.getname()
+ if base_type_type == "derived"
+ else base_type_type.upper())
+ elif basetype_content_type == "struct":
infos["type"] = "Structure"
infos["elements"] = []
- for element in basetype_content["value"].getvariable():
+ for element in basetype_content.getvariable():
element_infos = {}
element_infos["Name"] = element.getname()
element_type = element.type.getcontent()
- if element_type["value"] is None or element_type["name"] in ["string", "wstring"]:
- element_infos["Type"] = element_type["name"].upper()
- elif element_type["name"] == "array":
+ element_type_type = element_type.getLocalTag()
+ if element_type_type == "array":
dimensions = []
- for dimension in element_type["value"].getdimension():
+ for dimension in element_type.getdimension():
dimensions.append((dimension.getlower(), dimension.getupper()))
- base_type = element_type["value"].baseType.getcontent()
- if base_type["value"] is None or base_type["name"] in ["string", "wstring"]:
- base_type_name = base_type["name"].upper()
- else:
- base_type_name = base_type["value"].getname()
- element_infos["Type"] = ("array", base_type_name, dimensions)
+ base_type = element_type.baseType.getcontent()
+ base_type_type = element_type.getLocalTag()
+ element_infos["Type"] = ("array",
+ base_type.getname()
+ if base_type_type == "derived"
+ else base_type_type.upper(), dimensions)
+ elif element_type_type == "derived":
+ element_infos["Type"] = element_type.getname()
else:
- element_infos["Type"] = element_type["value"].getname()
+ element_infos["Type"] = element_type_type.upper()
if element.initialValue is not None:
element_infos["Initial Value"] = str(element.initialValue.getvalue())
else:
element_infos["Initial Value"] = ""
infos["elements"].append(element_infos)
+ else:
+ infos["type"] = "Directly"
+ infos["base_type"] = (basetype_content.getname()
+ if basetype_content_type == "derived"
+ else basetype_content_type.upper())
+
if datatype.initialValue is not None:
infos["initial"] = str(datatype.initialValue.getvalue())
else:
@@ -1929,45 +1975,46 @@
datatype = self.Project.getdataType(words[1])
if infos["type"] == "Directly":
if infos["base_type"] in self.GetBaseTypes():
- if infos["base_type"] == "STRING":
- datatype.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif infos["base_type"] == "WSTRING":
- datatype.baseType.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
- else:
- datatype.baseType.setcontent({"name" : infos["base_type"], "value" : None})
+ datatype.baseType.setcontent(PLCOpenParser.CreateElement(
+ infos["base_type"].lower()
+ if infos["base_type"] in ["STRING", "WSTRING"]
+ else infos["base_type"], "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(infos["base_type"])
- datatype.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
+ datatype.baseType.setcontent(derived_datatype)
elif infos["type"] == "Subrange":
- if infos["base_type"] in GetSubTypes("ANY_UINT"):
- subrange = plcopen.derivedTypes_subrangeUnsigned()
- datatype.baseType.setcontent({"name" : "subrangeUnsigned", "value" : subrange})
- else:
- subrange = plcopen.derivedTypes_subrangeSigned()
- datatype.baseType.setcontent({"name" : "subrangeSigned", "value" : subrange})
+ subrange = PLCOpenParser.CreateElement(
+ "subrangeUnsigned"
+ if infos["base_type"] in GetSubTypes("ANY_UINT")
+ else "subrangeSigned", "dataType")
+ datatype.baseType.setcontent(subrange)
subrange.range.setlower(infos["min"])
subrange.range.setupper(infos["max"])
if infos["base_type"] in self.GetBaseTypes():
- subrange.baseType.setcontent({"name" : infos["base_type"], "value" : None})
+ subrange.baseType.setcontent(
+ PLCOpenParser.CreateElement(infos["base_type"], "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(infos["base_type"])
- subrange.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
+ subrange.baseType.setcontent(derived_datatype)
elif infos["type"] == "Enumerated":
- enumerated = plcopen.derivedTypes_enum()
+ enumerated = PLCOpenParser.CreateElement("enum", "dataType")
+ datatype.baseType.setcontent(enumerated)
+ values = PLCOpenParser.CreateElement("values", "enum")
+ enumerated.setvalues(values)
for i, enum_value in enumerate(infos["values"]):
- value = plcopen.values_value()
+ value = PLCOpenParser.CreateElement("value", "values")
value.setname(enum_value)
if i == 0:
- enumerated.values.setvalue([value])
+ values.setvalue([value])
else:
- enumerated.values.appendvalue(value)
- datatype.baseType.setcontent({"name" : "enum", "value" : enumerated})
+ values.appendvalue(value)
elif infos["type"] == "Array":
- array = plcopen.derivedTypes_array()
+ array = PLCOpenParser.CreateElement("array", "dataType")
+ datatype.baseType.setcontent(array)
for i, dimension in enumerate(infos["dimensions"]):
- dimension_range = plcopen.rangeSigned()
+ dimension_range = PLCOpenParser.CreateElement("dimension", "array")
dimension_range.setlower(dimension[0])
dimension_range.setupper(dimension[1])
if i == 0:
@@ -1975,28 +2022,28 @@
else:
array.appenddimension(dimension_range)
if infos["base_type"] in self.GetBaseTypes():
- if infos["base_type"] == "STRING":
- array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif infos["base_type"] == "WSTRING":
- array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
- else:
- array.baseType.setcontent({"name" : infos["base_type"], "value" : None})
+ array.baseType.setcontent(PLCOpenParser.CreateElement(
+ infos["base_type"].lower()
+ if infos["base_type"] in ["STRING", "WSTRING"]
+ else infos["base_type"], "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(infos["base_type"])
- array.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
- datatype.baseType.setcontent({"name" : "array", "value" : array})
+ array.baseType.setcontent(derived_datatype)
elif infos["type"] == "Structure":
- struct = plcopen.varListPlain()
+ struct = PLCOpenParser.CreateElement("struct", "dataType")
+ datatype.baseType.setcontent(struct)
for i, element_infos in enumerate(infos["elements"]):
- element = plcopen.varListPlain_variable()
+ element = PLCOpenParser.CreateElement("variable", "struct")
element.setname(element_infos["Name"])
+ element_type = PLCOpenParser.CreateElement("type", "variable")
if isinstance(element_infos["Type"], TupleType):
if element_infos["Type"][0] == "array":
array_type, base_type_name, dimensions = element_infos["Type"]
- array = plcopen.derivedTypes_array()
+ array = PLCOpenParser.CreateElement("array", "dataType")
+ element_type.setcontent(array)
for j, dimension in enumerate(dimensions):
- dimension_range = plcopen.rangeSigned()
+ dimension_range = PLCOpenParser.CreateElement("dimension", "array")
dimension_range.setlower(dimension[0])
dimension_range.setupper(dimension[1])
if j == 0:
@@ -2004,45 +2051,39 @@
else:
array.appenddimension(dimension_range)
if base_type_name in self.GetBaseTypes():
- if base_type_name == "STRING":
- array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif base_type_name == "WSTRING":
- array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
- else:
- array.baseType.setcontent({"name" : base_type_name, "value" : None})
+ array.baseType.setcontent(PLCOpenParser.CreateElement(
+ base_type_name.lower()
+ if base_type_name in ["STRING", "WSTRING"]
+ else base_type_name, "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(base_type_name)
- array.baseType.setcontent({"name" : "derived", "value" : derived_datatype})
- element.type.setcontent({"name" : "array", "value" : array})
+ array.baseType.setcontent(derived_datatype)
elif element_infos["Type"] in self.GetBaseTypes():
- if element_infos["Type"] == "STRING":
- element.type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
- elif element_infos["Type"] == "WSTRING":
- element.type.setcontent({"name" : "wstring", "value" : plcopen.wstring()})
- else:
- element.type.setcontent({"name" : element_infos["Type"], "value" : None})
+ element_type.setcontent(
+ PLCOpenParser.CreateElement(
+ element_infos["Type"].lower()
+ if element_infos["Type"] in ["STRING", "WSTRING"]
+ else element_infos["Type"], "dataType"))
else:
- derived_datatype = plcopen.derivedTypes_derived()
+ derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")
derived_datatype.setname(element_infos["Type"])
- element.type.setcontent({"name" : "derived", "value" : derived_datatype})
+ element_type.setcontent(derived_datatype)
+ element.settype(element_type)
if element_infos["Initial Value"] != "":
- value = plcopen.value()
+ value = PLCOpenParser.CreateElement("initialValue", "variable")
value.setvalue(element_infos["Initial Value"])
element.setinitialValue(value)
if i == 0:
struct.setvariable([element])
else:
struct.appendvariable(element)
- datatype.baseType.setcontent({"name" : "struct", "value" : struct})
if infos["initial"] != "":
if datatype.initialValue is None:
- datatype.initialValue = plcopen.value()
+ datatype.initialValue = PLCOpenParser.CreateElement("initialValue", "dataType")
datatype.initialValue.setvalue(infos["initial"])
else:
datatype.initialValue = None
- self.Project.RefreshDataTypeHierarchy()
- self.Project.RefreshElementUsingTree()
self.BufferProject()
#-------------------------------------------------------------------------------
@@ -2128,7 +2169,6 @@
element = self.GetEditedElement(tagname)
if element is not None:
element.settext(text)
- self.Project.RefreshElementUsingTree()
# Return the edited element text
def GetEditedElementText(self, tagname, debug = False):
@@ -2173,22 +2213,28 @@
def GetEditedElementCopy(self, tagname, debug = False):
element = self.GetEditedElement(tagname, debug)
if element is not None:
- name = element.__class__.__name__
- return element.generateXMLText(name.split("_")[-1], 0)
+ return element.tostring()
return ""
def GetEditedElementInstancesCopy(self, tagname, blocks_id = None, wires = None, debug = False):
element = self.GetEditedElement(tagname, debug)
text = ""
if element is not None:
- wires = dict([(wire, True) for wire in wires if wire[0] in blocks_id and wire[1] in blocks_id])
+ wires = dict([(wire, True)
+ for wire in wires
+ if wire[0] in blocks_id and wire[1] in blocks_id])
+ copy_body = PLCOpenParser.CreateElement("body", "pou")
+ element.append(copy_body)
+ copy_body.setcontent(
+ PLCOpenParser.CreateElement(element.getbodyType(), "body"))
for id in blocks_id:
instance = element.getinstance(id)
if instance is not None:
- instance_copy = self.Copy(instance)
+ copy_body.appendcontentInstance(self.Copy(instance))
+ instance_copy = copy_body.getcontentInstance(id)
instance_copy.filterConnections(wires)
- name = instance_copy.__class__.__name__
- text += instance_copy.generateXMLText(name.split("_")[-1], 0)
+ text += instance_copy.tostring()
+ element.remove(copy_body)
return text
def GenerateNewName(self, tagname, name, format, start_idx=0, exclude={}, debug=False):
@@ -2201,9 +2247,10 @@
element = self.GetEditedElement(tagname, debug)
if element is not None and element.getbodyType() not in ["ST", "IL"]:
for instance in element.getinstances():
- if isinstance(instance, (plcopen.sfcObjects_step,
- plcopen.commonObjects_connector,
- plcopen.commonObjects_continuation)):
+ if isinstance(instance,
+ (PLCOpenParser.GetElementClass("step", "sfcObjects"),
+ PLCOpenParser.GetElementClass("connector", "commonObjects"),
+ PLCOpenParser.GetElementClass("continuation", "commonObjects"))):
names[instance.getname().upper()] = True
else:
project = self.GetProject(debug)
@@ -2229,10 +2276,6 @@
i += 1
return name
- CheckPasteCompatibility = {"SFC": lambda name: True,
- "LD": lambda name: not name.startswith("sfcObjects"),
- "FBD": lambda name: name.startswith("fbdObjects") or name.startswith("commonObjects")}
-
def PasteEditedElementInstances(self, tagname, text, new_pos, middle=False, debug=False):
element = self.GetEditedElement(tagname, debug)
element_name, element_type = self.GetEditedElementType(tagname, debug)
@@ -2250,62 +2293,46 @@
used_id = dict([(instance.getlocalId(), True) for instance in element.getinstances()])
new_id = {}
- text = "<paste>%s</paste>"%text
-
try:
- tree = minidom.parseString(text.encode("utf-8"))
+ instances = LoadPouInstances(text.encode("utf-8"), bodytype)
+ if len(instances) == 0:
+ raise ValueError
except:
return _("Invalid plcopen element(s)!!!")
- instances = []
+
exclude = {}
- for root in tree.childNodes:
- if root.nodeType == tree.ELEMENT_NODE and root.nodeName == "paste":
- for child in root.childNodes:
- if child.nodeType == tree.ELEMENT_NODE:
- if not child.nodeName in plcopen.ElementNameToClass:
- return _("\"%s\" element can't be pasted here!!!")%child.nodeName
-
- classname = plcopen.ElementNameToClass[child.nodeName]
- if not self.CheckPasteCompatibility[bodytype](classname):
- return _("\"%s\" element can't be pasted here!!!")%child.nodeName
-
- classobj = getattr(plcopen, classname, None)
- if classobj is not None:
- instance = classobj()
- instance.loadXMLTree(child)
- if child.nodeName == "block":
- blockname = instance.getinstanceName()
- if blockname is not None:
- blocktype = instance.gettypeName()
- if element_type == "function":
- return _("FunctionBlock \"%s\" can't be pasted in a Function!!!")%blocktype
- blockname = self.GenerateNewName(tagname,
- blockname,
- "%s%%d"%blocktype,
- debug=debug)
- exclude[blockname] = True
- instance.setinstanceName(blockname)
- self.AddEditedElementPouVar(tagname, blocktype, blockname)
- elif child.nodeName == "step":
- stepname = self.GenerateNewName(tagname,
- instance.getname(),
- "Step%d",
- exclude=exclude,
- debug=debug)
- exclude[stepname] = True
- instance.setname(stepname)
- localid = instance.getlocalId()
- if not used_id.has_key(localid):
- new_id[localid] = True
- instances.append((child.nodeName, instance))
-
- if len(instances) == 0:
- return _("Invalid plcopen element(s)!!!")
+ for instance in instances:
+ element.addinstance(instance)
+ instance_type = instance.getLocalTag()
+ if instance_type == "block":
+ blockname = instance.getinstanceName()
+ if blockname is not None:
+ blocktype = instance.gettypeName()
+ if element_type == "function":
+ return _("FunctionBlock \"%s\" can't be pasted in a Function!!!")%blocktype
+ blockname = self.GenerateNewName(tagname,
+ blockname,
+ "%s%%d"%blocktype,
+ debug=debug)
+ exclude[blockname] = True
+ instance.setinstanceName(blockname)
+ self.AddEditedElementPouVar(tagname, blocktype, blockname)
+ elif instance_type == "step":
+ stepname = self.GenerateNewName(tagname,
+ instance.getname(),
+ "Step%d",
+ exclude=exclude,
+ debug=debug)
+ exclude[stepname] = True
+ instance.setname(stepname)
+ localid = instance.getlocalId()
+ if not used_id.has_key(localid):
+ new_id[localid] = True
idx = 1
translate_id = {}
- bbox = plcopen.rect()
- for name, instance in instances:
+ bbox = rect()
+ for instance in instances:
localId = instance.getlocalId()
bbox.union(instance.getBoundingBox())
if used_id.has_key(localId):
@@ -2338,12 +2365,11 @@
diff = (new_pos[0] - x, new_pos[1] - y)
connections = {}
- for name, instance in instances:
+ for instance in instances:
connections.update(instance.updateConnectionsId(translate_id))
if getattr(instance, "setexecutionOrderId", None) is not None:
instance.setexecutionOrderId(0)
instance.translate(*diff)
- element.addinstance(name, instance)
return new_id, connections
@@ -2392,12 +2418,11 @@
for var in varlist.getvariable():
if var.getname() == varname:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- return vartype_content["value"].getname()
- elif vartype_content["name"] in ["string", "wstring"]:
- return vartype_content["name"].upper()
+ vartype_content_type = vartype_content.getLocalTag()
+ if vartype_content_type == "derived":
+ return vartype_content.getname()
else:
- return vartype_content["name"]
+ return vartype_content_type.upper()
return None
def SetConnectionWires(self, connection, connector):
@@ -2457,15 +2482,14 @@
def AddEditedElementBlock(self, tagname, id, blocktype, blockname = None):
element = self.GetEditedElement(tagname)
if element is not None:
- block = plcopen.fbdObjects_block()
+ block = PLCOpenParser.CreateElement("block", "fbdObjects")
block.setlocalId(id)
block.settypeName(blocktype)
blocktype_infos = self.GetBlockType(blocktype)
if blocktype_infos["type"] != "function" and blockname is not None:
block.setinstanceName(blockname)
self.AddEditedElementPouVar(tagname, blocktype, blockname)
- element.addinstance("block", block)
- self.Project.RefreshElementUsingTree()
+ element.addinstance(block)
def SetEditedElementBlockInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2510,7 +2534,8 @@
block.inputVariables.setvariable([])
block.outputVariables.setvariable([])
for connector in value["inputs"]:
- variable = plcopen.inputVariables_variable()
+ variable = PLCOpenParser.CreateElement("variable", "inputVariables")
+ block.inputVariables.appendvariable(variable)
variable.setformalParameter(connector.GetName())
if connector.IsNegated():
variable.setnegated(True)
@@ -2519,9 +2544,9 @@
position = connector.GetRelPosition()
variable.connectionPointIn.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(variable.connectionPointIn, connector)
- block.inputVariables.appendvariable(variable)
for connector in value["outputs"]:
- variable = plcopen.outputVariables_variable()
+ variable = PLCOpenParser.CreateElement("variable", "outputVariables")
+ block.outputVariables.appendvariable(variable)
variable.setformalParameter(connector.GetName())
if connector.IsNegated():
variable.setnegated(True)
@@ -2530,23 +2555,17 @@
position = connector.GetRelPosition()
variable.addconnectionPointOut()
variable.connectionPointOut.setrelPositionXY(position.x, position.y)
- block.outputVariables.appendvariable(variable)
- self.Project.RefreshElementUsingTree()
+ block.tostring()
- def AddEditedElementVariable(self, tagname, id, type):
+ def AddEditedElementVariable(self, tagname, id, var_type):
element = self.GetEditedElement(tagname)
- if element is not None:
- if type == INPUT:
- name = "inVariable"
- variable = plcopen.fbdObjects_inVariable()
- elif type == OUTPUT:
- name = "outVariable"
- variable = plcopen.fbdObjects_outVariable()
- elif type == INOUT:
- name = "inOutVariable"
- variable = plcopen.fbdObjects_inOutVariable()
+ if element is not None:
+ variable = PLCOpenParser.CreateElement(
+ {INPUT: "inVariable",
+ OUTPUT: "outVariable",
+ INOUT: "inOutVariable"}[var_type], "fbdObjects")
variable.setlocalId(id)
- element.addinstance(name, variable)
+ element.addinstance(variable)
def SetEditedElementVariableInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2556,7 +2575,9 @@
return
for param, value in infos.items():
if param == "name":
- variable.setexpression(value)
+ expression = PLCOpenParser.CreateElement("expression", variable.getLocalTag())
+ expression.text = value
+ variable.setexpression(expression)
elif param == "executionOrder" and variable.getexecutionOrderId() != value:
element.setelementExecutionOrder(variable, value)
elif param == "height":
@@ -2592,17 +2613,14 @@
variable.connectionPointIn.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(variable.connectionPointIn, input)
- def AddEditedElementConnection(self, tagname, id, type):
+ def AddEditedElementConnection(self, tagname, id, connection_type):
element = self.GetEditedElement(tagname)
if element is not None:
- if type == CONNECTOR:
- name = "connector"
- connection = plcopen.commonObjects_connector()
- elif type == CONTINUATION:
- name = "continuation"
- connection = plcopen.commonObjects_continuation()
+ connection = PLCOpenParser.CreateElement(
+ {CONNECTOR: "connector",
+ CONTINUATION: "continuation"}[connection_type], "commonObjects")
connection.setlocalId(id)
- element.addinstance(name, connection)
+ element.addinstance(connection)
def SetEditedElementConnectionInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2623,10 +2641,10 @@
connection.sety(value)
elif param == "connector":
position = value.GetRelPosition()
- if isinstance(connection, plcopen.commonObjects_continuation):
+ if isinstance(connection, PLCOpenParser.GetElementClass("continuation", "commonObjects")):
connection.addconnectionPointOut()
connection.connectionPointOut.setrelPositionXY(position.x, position.y)
- elif isinstance(connection, plcopen.commonObjects_connector):
+ elif isinstance(connection, PLCOpenParser.GetElementClass("connector", "commonObjects")):
connection.addconnectionPointIn()
connection.connectionPointIn.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(connection.connectionPointIn, value)
@@ -2634,9 +2652,9 @@
def AddEditedElementComment(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- comment = plcopen.commonObjects_comment()
+ comment = PLCOpenParser.CreateElement("comment", "commonObjects")
comment.setlocalId(id)
- element.addinstance("comment", comment)
+ element.addinstance(comment)
def SetEditedElementCommentInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2654,17 +2672,14 @@
elif param == "y":
comment.sety(value)
- def AddEditedElementPowerRail(self, tagname, id, type):
+ def AddEditedElementPowerRail(self, tagname, id, powerrail_type):
element = self.GetEditedElement(tagname)
if element is not None:
- if type == LEFTRAIL:
- name = "leftPowerRail"
- powerrail = plcopen.ldObjects_leftPowerRail()
- elif type == RIGHTRAIL:
- name = "rightPowerRail"
- powerrail = plcopen.ldObjects_rightPowerRail()
+ powerrail = PLCOpenParser.CreateElement(
+ {LEFTRAIL: "leftPowerRail",
+ RIGHTRAIL: "rightPowerRail"}[powerrail_type], "ldObjects")
powerrail.setlocalId(id)
- element.addinstance(name, powerrail)
+ element.addinstance(powerrail)
def SetEditedElementPowerRailInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2682,28 +2697,28 @@
elif param == "y":
powerrail.sety(value)
elif param == "connectors":
- if isinstance(powerrail, plcopen.ldObjects_leftPowerRail):
+ if isinstance(powerrail, PLCOpenParser.GetElementClass("leftPowerRail", "ldObjects")):
powerrail.setconnectionPointOut([])
for connector in value["outputs"]:
position = connector.GetRelPosition()
- connection = plcopen.leftPowerRail_connectionPointOut()
+ connection = PLCOpenParser.CreateElement("connectionPointOut", "leftPowerRail")
+ powerrail.appendconnectionPointOut(connection)
connection.setrelPositionXY(position.x, position.y)
- powerrail.connectionPointOut.append(connection)
- elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail):
+ elif isinstance(powerrail, PLCOpenParser.GetElementClass("rightPowerRail", "ldObjects")):
powerrail.setconnectionPointIn([])
for connector in value["inputs"]:
position = connector.GetRelPosition()
- connection = plcopen.connectionPointIn()
+ connection = PLCOpenParser.CreateElement("connectionPointIn", "rightPowerRail")
+ powerrail.appendconnectionPointIn(connection)
connection.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(connection, connector)
- powerrail.connectionPointIn.append(connection)
-
+
def AddEditedElementContact(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- contact = plcopen.ldObjects_contact()
+ contact = PLCOpenParser.CreateElement("contact", "ldObjects")
contact.setlocalId(id)
- element.addinstance("contact", contact)
+ element.addinstance(contact)
def SetEditedElementContactInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2713,20 +2728,17 @@
return
for param, value in infos.items():
if param == "name":
- contact.setvariable(value)
+ variable = PLCOpenParser.CreateElement("variable", "contact")
+ variable.text = value
+ contact.setvariable(variable)
elif param == "type":
- if value == CONTACT_NORMAL:
- contact.setnegated(False)
- contact.setedge("none")
- elif value == CONTACT_REVERSE:
- contact.setnegated(True)
- contact.setedge("none")
- elif value == CONTACT_RISING:
- contact.setnegated(False)
- contact.setedge("rising")
- elif value == CONTACT_FALLING:
- contact.setnegated(False)
- contact.setedge("falling")
+ negated, edge = {
+ CONTACT_NORMAL: (False, "none"),
+ CONTACT_REVERSE: (True, "none"),
+ CONTACT_RISING: (False, "rising"),
+ CONTACT_FALLING: (False, "falling")}[value]
+ contact.setnegated(negated)
+ contact.setedge(edge)
elif param == "height":
contact.setheight(value)
elif param == "width":
@@ -2749,9 +2761,9 @@
def AddEditedElementCoil(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- coil = plcopen.ldObjects_coil()
+ coil = PLCOpenParser.CreateElement("coil", "ldObjects")
coil.setlocalId(id)
- element.addinstance("coil", coil)
+ element.addinstance(coil)
def SetEditedElementCoilInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2761,32 +2773,20 @@
return
for param, value in infos.items():
if param == "name":
- coil.setvariable(value)
+ variable = PLCOpenParser.CreateElement("variable", "coil")
+ variable.text = value
+ coil.setvariable(variable)
elif param == "type":
- if value == COIL_NORMAL:
- coil.setnegated(False)
- coil.setstorage("none")
- coil.setedge("none")
- elif value == COIL_REVERSE:
- coil.setnegated(True)
- coil.setstorage("none")
- coil.setedge("none")
- elif value == COIL_SET:
- coil.setnegated(False)
- coil.setstorage("set")
- coil.setedge("none")
- elif value == COIL_RESET:
- coil.setnegated(False)
- coil.setstorage("reset")
- coil.setedge("none")
- elif value == COIL_RISING:
- coil.setnegated(False)
- coil.setstorage("none")
- coil.setedge("rising")
- elif value == COIL_FALLING:
- coil.setnegated(False)
- coil.setstorage("none")
- coil.setedge("falling")
+ negated, storage, edge = {
+ COIL_NORMAL: (False, "none", "none"),
+ COIL_REVERSE: (True, "none", "none"),
+ COIL_SET: (False, "set", "none"),
+ COIL_RESET: (False, "reset", "none"),
+ COIL_RISING: (False, "none", "rising"),
+ COIL_FALLING: (False, "none", "falling")}[value]
+ coil.setnegated(negated)
+ coil.setstorage(storage)
+ coil.setedge(edge)
elif param == "height":
coil.setheight(value)
elif param == "width":
@@ -2809,9 +2809,9 @@
def AddEditedElementStep(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- step = plcopen.sfcObjects_step()
+ step = PLCOpenParser.CreateElement("step", "sfcObjects")
step.setlocalId(id)
- element.addinstance("step", step)
+ element.addinstance(step)
def SetEditedElementStepInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2859,9 +2859,9 @@
def AddEditedElementTransition(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- transition = plcopen.sfcObjects_transition()
+ transition = PLCOpenParser.CreateElement("transition", "sfcObjects")
transition.setlocalId(id)
- element.addinstance("transition", transition)
+ element.addinstance(transition)
def SetEditedElementTransitionInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2897,25 +2897,31 @@
transition.connectionPointOut.setrelPositionXY(position.x, position.y)
elif infos.get("type", None) == "connection" and param == "connection" and value:
transition.setconditionContent("connection", None)
- self.SetConnectionWires(transition.condition.content["value"], value)
-
- def AddEditedElementDivergence(self, tagname, id, type):
+ self.SetConnectionWires(transition.condition.content, value)
+
+ def AddEditedElementDivergence(self, tagname, id, divergence_type):
element = self.GetEditedElement(tagname)
if element is not None:
- if type == SELECTION_DIVERGENCE:
- name = "selectionDivergence"
- divergence = plcopen.sfcObjects_selectionDivergence()
- elif type == SELECTION_CONVERGENCE:
- name = "selectionConvergence"
- divergence = plcopen.sfcObjects_selectionConvergence()
- elif type == SIMULTANEOUS_DIVERGENCE:
- name = "simultaneousDivergence"
- divergence = plcopen.sfcObjects_simultaneousDivergence()
- elif type == SIMULTANEOUS_CONVERGENCE:
- name = "simultaneousConvergence"
- divergence = plcopen.sfcObjects_simultaneousConvergence()
+ divergence = PLCOpenParser.CreateElement(
+ {SELECTION_DIVERGENCE: "selectionDivergence",
+ SELECTION_CONVERGENCE: "selectionConvergence",
+ SIMULTANEOUS_DIVERGENCE: "simultaneousDivergence",
+ SIMULTANEOUS_CONVERGENCE: "simultaneousConvergence"}.get(
+ divergence_type), "sfcObjects")
divergence.setlocalId(id)
- element.addinstance(name, divergence)
+ element.addinstance(divergence)
+
+ DivergenceTypes = [
+ (divergence_type,
+ PLCOpenParser.GetElementClass(divergence_type, "sfcObjects"))
+ for divergence_type in ["selectionDivergence", "simultaneousDivergence",
+ "selectionConvergence", "simultaneousConvergence"]]
+
+ def GetDivergenceType(self, divergence):
+ for divergence_type, divergence_class in self.DivergenceTypes:
+ if isinstance(divergence, divergence_class):
+ return divergence_type
+ return None
def SetEditedElementDivergenceInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2934,7 +2940,8 @@
divergence.sety(value)
elif param == "connectors":
input_connectors = value["inputs"]
- if isinstance(divergence, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)):
+ divergence_type = self.GetDivergenceType(divergence)
+ if divergence_type in ["selectionDivergence", "simultaneousDivergence"]:
position = input_connectors[0].GetRelPosition()
divergence.addconnectionPointIn()
divergence.connectionPointIn.setrelPositionXY(position.x, position.y)
@@ -2943,15 +2950,12 @@
divergence.setconnectionPointIn([])
for input_connector in input_connectors:
position = input_connector.GetRelPosition()
- if isinstance(divergence, plcopen.sfcObjects_selectionConvergence):
- connection = plcopen.selectionConvergence_connectionPointIn()
- else:
- connection = plcopen.connectionPointIn()
+ connection = PLCOpenParser.CreateElement("connectionPointIn", divergence_type)
+ divergence.appendconnectionPointIn(connection)
connection.setrelPositionXY(position.x, position.y)
self.SetConnectionWires(connection, input_connector)
- divergence.appendconnectionPointIn(connection)
output_connectors = value["outputs"]
- if isinstance(divergence, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)):
+ if divergence_type in ["selectionConvergence", "simultaneousConvergence"]:
position = output_connectors[0].GetRelPosition()
divergence.addconnectionPointOut()
divergence.connectionPointOut.setrelPositionXY(position.x, position.y)
@@ -2959,19 +2963,16 @@
divergence.setconnectionPointOut([])
for output_connector in output_connectors:
position = output_connector.GetRelPosition()
- if isinstance(divergence, plcopen.sfcObjects_selectionDivergence):
- connection = plcopen.selectionDivergence_connectionPointOut()
- else:
- connection = plcopen.simultaneousDivergence_connectionPointOut()
+ connection = PLCOpenParser.CreateElement("connectionPointOut", divergence_type)
+ divergence.appendconnectionPointOut(connection)
connection.setrelPositionXY(position.x, position.y)
- divergence.appendconnectionPointOut(connection)
-
+
def AddEditedElementJump(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- jump = plcopen.sfcObjects_jumpStep()
+ jump = PLCOpenParser.CreateElement("jumpStep", "sfcObjects")
jump.setlocalId(id)
- element.addinstance("jumpStep", jump)
+ element.addinstance(jump)
def SetEditedElementJumpInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -2999,9 +3000,9 @@
def AddEditedElementActionBlock(self, tagname, id):
element = self.GetEditedElement(tagname)
if element is not None:
- actionBlock = plcopen.commonObjects_actionBlock()
+ actionBlock = PLCOpenParser.CreateElement("actionBlock", "commonObjects")
actionBlock.setlocalId(id)
- element.addinstance("actionBlock", actionBlock)
+ element.addinstance(actionBlock)
def SetEditedElementActionBlockInfos(self, tagname, id, infos):
element = self.GetEditedElement(tagname)
@@ -3030,10 +3031,9 @@
element = self.GetEditedElement(tagname)
if element is not None:
instance = element.getinstance(id)
- if isinstance(instance, plcopen.fbdObjects_block):
+ if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName())
element.removeinstance(id)
- self.Project.RefreshElementUsingTree()
def GetEditedResourceVariables(self, tagname, debug = False):
varlist = []
@@ -3053,7 +3053,8 @@
resource.setpouInstance([])
task_list = {}
for task in tasks:
- new_task = plcopen.resource_task()
+ new_task = PLCOpenParser.CreateElement("task", "resource")
+ resource.appendtask(new_task)
new_task.setname(task["Name"])
if task["Triggering"] == "Interrupt":
new_task.setsingle(task["Single"])
@@ -3073,12 +3074,16 @@
new_task.setpriority(int(task["Priority"]))
if task["Name"] != "":
task_list[task["Name"]] = new_task
- resource.appendtask(new_task)
for instance in instances:
- new_instance = plcopen.pouInstance()
+ task = task_list.get(instance["Task"])
+ if task is not None:
+ new_instance = PLCOpenParser.CreateElement("pouInstance", "task")
+ task.appendpouInstance(new_instance)
+ else:
+ new_instance = PLCOpenParser.CreateElement("pouInstance", "resource")
+ resource.appendpouInstance(new_instance)
new_instance.setname(instance["Name"])
new_instance.settypeName(instance["Type"])
- task_list.get(instance["Task"], resource).appendpouInstance(new_instance)
def GetEditedResourceInfos(self, tagname, debug = False):
resource = self.GetEditedElement(tagname, debug)
@@ -3136,31 +3141,20 @@
return tasks_data, instances_data
def OpenXMLFile(self, filepath):
- xmlfile = open(filepath, 'r')
- tree = minidom.parse(xmlfile)
- xmlfile.close()
+ try:
+ self.Project = LoadProject(filepath)
+ except Exception, e:
+ return _("Project file syntax error:\n\n") + str(e)
+ self.SetFilePath(filepath)
+ self.CreateProjectBuffer(True)
+ self.ProgramChunks = []
+ self.ProgramOffset = 0
+ self.NextCompiledProject = self.Copy(self.Project)
+ self.CurrentCompiledProject = None
+ self.Buffering = False
+ self.CurrentElementEditing = None
+ return None
- self.Project = plcopen.project()
- for child in tree.childNodes:
- if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "project":
- try:
- result = self.Project.loadXMLTree(child)
- except ValueError, e:
- return _("Project file syntax error:\n\n") + str(e)
- self.SetFilePath(filepath)
- self.Project.RefreshElementUsingTree()
- self.Project.RefreshDataTypeHierarchy()
- self.Project.RefreshCustomBlockTypes()
- self.CreateProjectBuffer(True)
- self.ProgramChunks = []
- self.ProgramOffset = 0
- self.NextCompiledProject = self.Copy(self.Project)
- self.CurrentCompiledProject = None
- self.Buffering = False
- self.CurrentElementEditing = None
- return None
- return _("No PLC project found")
-
def SaveXMLFile(self, filepath = None):
if not filepath and self.FilePath == "":
return False
@@ -3168,19 +3162,11 @@
contentheader = {"modificationDateTime": datetime.datetime(*localtime()[:6])}
self.Project.setcontentHeader(contentheader)
- text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- extras = {"xmlns" : "http://www.plcopen.org/xml/tc6.xsd",
- "xmlns:xhtml" : "http://www.w3.org/1999/xhtml",
- "xmlns:xsi" : "http://www.w3.org/2001/XMLSchema-instance",
- "xsi:schemaLocation" : "http://www.plcopen.org/xml/tc6.xsd"}
- text += self.Project.generateXMLText("project", 0, extras)
+ if filepath:
+ SaveProject(self.Project, filepath)
+ else:
+ SaveProject(self.Project, self.FilePath)
- if filepath:
- xmlfile = open(filepath,"w")
- else:
- xmlfile = open(self.FilePath,"w")
- xmlfile.write(text.encode("utf-8"))
- xmlfile.close()
self.MarkProjectAsSaved()
if filepath:
self.SetFilePath(filepath)
@@ -3207,11 +3193,11 @@
Return a copy of the project
"""
def Copy(self, model):
- return cPickle.loads(cPickle.dumps(model))
+ return deepcopy(model)
def CreateProjectBuffer(self, saved):
if self.ProjectBufferEnabled:
- self.ProjectBuffer = UndoBuffer(cPickle.dumps(self.Project), saved)
+ self.ProjectBuffer = UndoBuffer(PLCOpenParser.Dumps(self.Project), saved)
else:
self.ProjectBuffer = None
self.ProjectSaved = saved
@@ -3230,7 +3216,7 @@
def BufferProject(self):
if self.ProjectBuffer is not None:
- self.ProjectBuffer.Buffering(cPickle.dumps(self.Project))
+ self.ProjectBuffer.Buffering(PLCOpenParser.Dumps(self.Project))
else:
self.ProjectSaved = False
@@ -3242,7 +3228,7 @@
def EndBuffering(self):
if self.ProjectBuffer is not None and self.Buffering:
- self.ProjectBuffer.Buffering(cPickle.dumps(self.Project))
+ self.ProjectBuffer.Buffering(PLCOpenParser.Dumps(self.Project))
self.Buffering = False
def MarkProjectAsSaved(self):
@@ -3262,11 +3248,11 @@
def LoadPrevious(self):
self.EndBuffering()
if self.ProjectBuffer is not None:
- self.Project = cPickle.loads(self.ProjectBuffer.Previous())
+ self.Project = PLCOpenParser.Loads(self.ProjectBuffer.Previous())
def LoadNext(self):
if self.ProjectBuffer is not None:
- self.Project = cPickle.loads(self.ProjectBuffer.Next())
+ self.Project = PLCOpenParser.Loads(self.ProjectBuffer.Next())
def GetBufferState(self):
if self.ProjectBuffer is not None:
--- a/PLCGenerator.py Wed Sep 04 00:06:44 2013 +0200
+++ b/PLCGenerator.py Mon Sep 09 00:48:34 2013 +0200
@@ -22,7 +22,7 @@
#License along with this library; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-from plcopen import plcopen
+from plcopen import PLCOpenParser
from plcopen.structures import *
from types import *
import re
@@ -126,26 +126,25 @@
(datatype.getname(), (tagname, "name")),
(" : ", ())]
basetype_content = datatype.baseType.getcontent()
- # Data type derived directly from a string type
- if basetype_content["name"] in ["string", "wstring"]:
- datatype_def += [(basetype_content["name"].upper(), (tagname, "base"))]
+ basetype_content_type = basetype_content.getLocalTag()
# Data type derived directly from a user defined type
- elif basetype_content["name"] == "derived":
- basetype_name = basetype_content["value"].getname()
+ if basetype_content_type == "derived":
+ basetype_name = basetype_content.getname()
self.GenerateDataType(basetype_name)
datatype_def += [(basetype_name, (tagname, "base"))]
# Data type is a subrange
- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
- base_type = basetype_content["value"].baseType.getcontent()
+ elif basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
+ base_type = basetype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
# Subrange derived directly from a user defined type
- if base_type["name"] == "derived":
- basetype_name = base_type["value"].getname()
+ if base_type_type == "derived":
+ basetype_name = base_type_type.getname()
self.GenerateDataType(basetype_name)
# Subrange derived directly from an elementary type
else:
- basetype_name = base_type["name"]
- min_value = basetype_content["value"].range.getlower()
- max_value = basetype_content["value"].range.getupper()
+ basetype_name = base_type_type
+ min_value = basetype_content.range.getlower()
+ max_value = basetype_content.range.getupper()
datatype_def += [(basetype_name, (tagname, "base")),
(" (", ()),
("%s"%min_value, (tagname, "lower")),
@@ -153,63 +152,59 @@
("%s"%max_value, (tagname, "upper")),
(")",())]
# Data type is an enumerated type
- elif basetype_content["name"] == "enum":
+ elif basetype_content_type == "enum":
values = [[(value.getname(), (tagname, "value", i))]
- for i, value in enumerate(basetype_content["value"].values.getvalue())]
+ for i, value in enumerate(
+ basetype_content.xpath("ppx:values/ppx:value",
+ namespaces=PLCOpenParser.NSMAP))]
datatype_def += [("(", ())]
datatype_def += JoinList([(", ", ())], values)
datatype_def += [(")", ())]
# Data type is an array
- elif basetype_content["name"] == "array":
- base_type = basetype_content["value"].baseType.getcontent()
+ elif basetype_content_type == "array":
+ base_type = basetype_content.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
# Array derived directly from a user defined type
- if base_type["name"] == "derived":
- basetype_name = base_type["value"].getname()
+ if base_type_type == "derived":
+ basetype_name = base_type.getname()
self.GenerateDataType(basetype_name)
- # Array derived directly from a string type
- elif base_type["name"] in ["string", "wstring"]:
- basetype_name = base_type["name"].upper()
# Array derived directly from an elementary type
else:
- basetype_name = base_type["name"]
+ basetype_name = base_type_type.upper()
dimensions = [[("%s"%dimension.getlower(), (tagname, "range", i, "lower")),
("..", ()),
("%s"%dimension.getupper(), (tagname, "range", i, "upper"))]
- for i, dimension in enumerate(basetype_content["value"].getdimension())]
+ for i, dimension in enumerate(basetype_content.getdimension())]
datatype_def += [("ARRAY [", ())]
datatype_def += JoinList([(",", ())], dimensions)
datatype_def += [("] OF " , ()),
(basetype_name, (tagname, "base"))]
# Data type is a structure
- elif basetype_content["name"] == "struct":
+ elif basetype_content_type == "struct":
elements = []
- for i, element in enumerate(basetype_content["value"].getvariable()):
+ for i, element in enumerate(basetype_content.getvariable()):
element_type = element.type.getcontent()
+ element_type_type = element_type.getLocalTag()
# Structure element derived directly from a user defined type
- if element_type["name"] == "derived":
- elementtype_name = element_type["value"].getname()
+ if element_type_type == "derived":
+ elementtype_name = element_type.getname()
self.GenerateDataType(elementtype_name)
- elif element_type["name"] == "array":
- base_type = element_type["value"].baseType.getcontent()
+ elif element_type_type == "array":
+ base_type = element_type.baseType.getcontent()
+ base_type_type = base_type.getLocalTag()
# Array derived directly from a user defined type
- if base_type["name"] == "derived":
- basetype_name = base_type["value"].getname()
+ if base_type_type == "derived":
+ basetype_name = base_type.getname()
self.GenerateDataType(basetype_name)
- # Array derived directly from a string type
- elif base_type["name"] in ["string", "wstring"]:
- basetype_name = base_type["name"].upper()
# Array derived directly from an elementary type
else:
- basetype_name = base_type["name"]
+ basetype_name = base_type_type.upper()
dimensions = ["%s..%s" % (dimension.getlower(), dimension.getupper())
- for dimension in element_type["value"].getdimension()]
+ for dimension in element_type.getdimension()]
elementtype_name = "ARRAY [%s] OF %s" % (",".join(dimensions), basetype_name)
- # Structure element derived directly from a string type
- elif element_type["name"] in ["string", "wstring"]:
- elementtype_name = element_type["name"].upper()
# Structure element derived directly from an elementary type
else:
- elementtype_name = element_type["name"]
+ elementtype_name = element_type_type.upper()
element_text = [("\n ", ()),
(element.getname(), (tagname, "struct", i, "name")),
(" : ", ()),
@@ -224,7 +219,7 @@
datatype_def += [("\n END_STRUCT", ())]
# Data type derived directly from a elementary type
else:
- datatype_def += [(basetype_content["name"], (tagname, "base"))]
+ datatype_def += [(basetype_content_type.upper(), (tagname, "base"))]
# Data type has an initial value
if datatype.initialValue is not None:
datatype_def += [(" := ", ()),
@@ -271,7 +266,7 @@
extra_variables = self.Controler.GetConfigurationExtraVariables()
if len(extra_variables) > 0:
if len(varlists) == 0:
- varlists = [(plcopen.interface_globalVars(), [])]
+ varlists = [(PLCOpenParser.CreateElement("globalVars", "interface"), [])]
varlists[-1][1].extend(extra_variables)
# Generate any global variable in configuration
@@ -289,8 +284,8 @@
# Generate any variable of this block
for var in varlist_variables:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- var_type = vartype_content["value"].getname()
+ if vartype_content.getLocalTag() == "derived":
+ var_type = vartype_content.getname()
self.GenerateDataType(var_type)
else:
var_type = var.gettypeAsText()
@@ -342,8 +337,8 @@
# Generate any variable of this block
for var in varlist.getvariable():
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- var_type = vartype_content["value"].getname()
+ if vartype_content.getLocalTag() == "derived":
+ var_type = vartype_content.getname()
self.GenerateDataType(var_type)
else:
var_type = var.gettypeAsText()
@@ -458,6 +453,24 @@
# Generator of POU programs
#-------------------------------------------------------------------------------
+[ConnectorClass, ContinuationClass, ActionBlockClass] = [
+ PLCOpenParser.GetElementClass(instance_name, "commonObjects")
+ for instance_name in ["connector", "continuation", "actionBlock"]]
+[InVariableClass, InOutVariableClass, OutVariableClass, BlockClass] = [
+ PLCOpenParser.GetElementClass(instance_name, "fbdObjects")
+ for instance_name in ["inVariable", "inOutVariable", "outVariable", "block"]]
+[ContactClass, CoilClass, LeftPowerRailClass, RightPowerRailClass] = [
+ PLCOpenParser.GetElementClass(instance_name, "ldObjects")
+ for instance_name in ["contact", "coil", "leftPowerRail", "rightPowerRail"]]
+[StepClass, TransitionClass, JumpStepClass,
+ SelectionConvergenceClass, SelectionDivergenceClass,
+ SimultaneousConvergenceClass, SimultaneousDivergenceClass] = [
+ PLCOpenParser.GetElementClass(instance_name, "sfcObjects")
+ for instance_name in ["step", "transition", "jumpStep",
+ "selectionConvergence", "selectionDivergence",
+ "simultaneousConvergence", "simultaneousDivergence"]]
+TransitionObjClass = PLCOpenParser.GetElementClass("transition", "transitions")
+ActionObjClass = PLCOpenParser.GetElementClass("action", "actions")
class PouProgramGenerator:
@@ -541,16 +554,17 @@
# Return connectors linked by a connection to the given connector
def GetConnectedConnector(self, connector, body):
links = connector.getconnections()
- if links and len(links) == 1:
+ if links is not None and len(links) == 1:
return self.GetLinkedConnector(links[0], body)
return None
def GetLinkedConnector(self, link, body):
parameter = link.getformalParameter()
instance = body.getcontentInstance(link.getrefLocalId())
- if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable, plcopen.commonObjects_continuation, plcopen.ldObjects_contact, plcopen.ldObjects_coil)):
+ if isinstance(instance, (InVariableClass, InOutVariableClass,
+ ContinuationClass, ContactClass, CoilClass)):
return instance.connectionPointOut
- elif isinstance(instance, plcopen.fbdObjects_block):
+ elif isinstance(instance, BlockClass):
outputvariables = instance.outputVariables.getvariable()
if len(outputvariables) == 1:
return outputvariables[0].connectionPointOut
@@ -565,7 +579,7 @@
blockposition = instance.getposition()
if point.x == blockposition.x + relposition[0] and point.y == blockposition.y + relposition[1]:
return variable.connectionPointOut
- elif isinstance(instance, plcopen.ldObjects_leftPowerRail):
+ elif isinstance(instance, LeftPowerRailClass):
outputconnections = instance.getconnectionPointOut()
if len(outputconnections) == 1:
return outputconnections[0]
@@ -591,25 +605,26 @@
if isinstance(body, ListType):
body = body[0]
body_content = body.getcontent()
+ body_type = body_content.getLocalTag()
if self.Type == "FUNCTION":
returntype_content = interface.getreturnType().getcontent()
- if returntype_content["name"] == "derived":
- self.ReturnType = returntype_content["value"].getname()
- elif returntype_content["name"] in ["string", "wstring"]:
- self.ReturnType = returntype_content["name"].upper()
- else:
- self.ReturnType = returntype_content["name"]
+ returntype_content_type = returntype_content.getLocalTag()
+ if returntype_content_type == "derived":
+ self.ReturnType = returntype_content.getname()
+ else:
+ self.ReturnType = returntype_content_type.upper()
for varlist in interface.getcontent():
variables = []
located = []
- for var in varlist["value"].getvariable():
+ varlist_type = varlist.getLocalTag()
+ for var in varlist.getvariable():
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- var_type = vartype_content["value"].getname()
+ if vartype_content.getLocalTag() == "derived":
+ var_type = vartype_content.getname()
blocktype = self.GetBlockType(var_type)
if blocktype is not None:
self.ParentGenerator.GeneratePouProgram(var_type)
- if body_content["name"] in ["FBD", "LD", "SFC"]:
+ if body_type in ["FBD", "LD", "SFC"]:
block = pou.getinstanceByName(var.getname())
else:
block = None
@@ -627,9 +642,9 @@
initial_value = None
address = var.getaddress()
if address is not None:
- located.append((vartype_content["value"].getname(), var.getname(), address, initial_value))
+ located.append((vartype_content.getname(), var.getname(), address, initial_value))
else:
- variables.append((vartype_content["value"].getname(), var.getname(), None, initial_value))
+ variables.append((vartype_content.getname(), var.getname(), None, initial_value))
else:
var_type = var.gettypeAsText()
initial = var.getinitialValue()
@@ -642,18 +657,18 @@
located.append((var_type, var.getname(), address, initial_value))
else:
variables.append((var_type, var.getname(), None, initial_value))
- if varlist["value"].getconstant():
+ if varlist.getconstant():
option = "CONSTANT"
- elif varlist["value"].getretain():
+ elif varlist.getretain():
option = "RETAIN"
- elif varlist["value"].getnonretain():
+ elif varlist.getnonretain():
option = "NON_RETAIN"
else:
option = None
if len(variables) > 0:
- self.Interface.append((varTypeNames[varlist["name"]], option, False, variables))
+ self.Interface.append((varTypeNames[varlist_type], option, False, variables))
if len(located) > 0:
- self.Interface.append((varTypeNames[varlist["name"]], option, True, located))
+ self.Interface.append((varTypeNames[varlist_type], option, True, located))
LITERAL_TYPES = {
"T": "TIME",
@@ -669,24 +684,25 @@
if isinstance(body, ListType):
body = body[0]
body_content = body.getcontent()
- body_type = body_content["name"]
+ body_type = body_content.getLocalTag()
if body_type in ["FBD", "LD", "SFC"]:
undefined_blocks = []
for instance in body.getcontentInstances():
- if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
- expression = instance.getexpression()
+ if isinstance(instance, (InVariableClass, OutVariableClass,
+ InOutVariableClass)):
+ expression = instance.getexpression().text
var_type = self.GetVariableType(expression)
- if isinstance(pou, plcopen.transitions_transition) and expression == pou.getname():
+ if (isinstance(pou, TransitionObjClass)
+ and expression == pou.getname()):
var_type = "BOOL"
- elif (not isinstance(pou, (plcopen.transitions_transition, plcopen.actions_action)) and
+ elif (not isinstance(pou, (TransitionObjClass, ActionObjClass)) and
pou.getpouType() == "function" and expression == pou.getname()):
returntype_content = pou.interface.getreturnType().getcontent()
- if returntype_content["name"] == "derived":
- var_type = returntype_content["value"].getname()
- elif returntype_content["name"] in ["string", "wstring"]:
- var_type = returntype_content["name"].upper()
+ returntype_content_type = returntype_content.getLocalTag()
+ if returntype_content_type == "derived":
+ var_type = returntype_content.getname()
else:
- var_type = returntype_content["name"]
+ var_type = returntype_content_type.upper()
elif var_type is None:
parts = expression.split("#")
if len(parts) > 1:
@@ -698,54 +714,58 @@
elif expression.startswith('"'):
var_type = "WSTRING"
if var_type is not None:
- if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable)):
+ if isinstance(instance, (InVariableClass, InOutVariableClass)):
for connection in self.ExtractRelatedConnections(instance.connectionPointOut):
self.ConnectionTypes[connection] = var_type
- if isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
+ if isinstance(instance, (OutVariableClass, InOutVariableClass)):
self.ConnectionTypes[instance.connectionPointIn] = var_type
connected = self.GetConnectedConnector(instance.connectionPointIn, body)
- if connected and not self.ConnectionTypes.has_key(connected):
- for connection in self.ExtractRelatedConnections(connected):
- self.ConnectionTypes[connection] = var_type
- elif isinstance(instance, (plcopen.ldObjects_contact, plcopen.ldObjects_coil)):
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
+ for related in self.ExtractRelatedConnections(connected):
+ self.ConnectionTypes[related] = var_type
+ elif isinstance(instance, (ContactClass, CoilClass)):
for connection in self.ExtractRelatedConnections(instance.connectionPointOut):
self.ConnectionTypes[connection] = "BOOL"
self.ConnectionTypes[instance.connectionPointIn] = "BOOL"
- connected = self.GetConnectedConnector(instance.connectionPointIn, body)
- if connected and not self.ConnectionTypes.has_key(connected):
- for connection in self.ExtractRelatedConnections(connected):
- self.ConnectionTypes[connection] = "BOOL"
- elif isinstance(instance, plcopen.ldObjects_leftPowerRail):
+ for link in instance.connectionPointIn.getconnections():
+ connected = self.GetLinkedConnector(link, body)
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
+ for related in self.ExtractRelatedConnections(connected):
+ self.ConnectionTypes[related] = "BOOL"
+ elif isinstance(instance, LeftPowerRailClass):
for connection in instance.getconnectionPointOut():
for related in self.ExtractRelatedConnections(connection):
self.ConnectionTypes[related] = "BOOL"
- elif isinstance(instance, plcopen.ldObjects_rightPowerRail):
+ elif isinstance(instance, RightPowerRailClass):
for connection in instance.getconnectionPointIn():
self.ConnectionTypes[connection] = "BOOL"
- connected = self.GetConnectedConnector(connection, body)
- if connected and not self.ConnectionTypes.has_key(connected):
- for connection in self.ExtractRelatedConnections(connected):
- self.ConnectionTypes[connection] = "BOOL"
- elif isinstance(instance, plcopen.sfcObjects_transition):
- content = instance.condition.getcontent()
- if content["name"] == "connection" and len(content["value"]) == 1:
- connected = self.GetLinkedConnector(content["value"][0], body)
- if connected and not self.ConnectionTypes.has_key(connected):
- for connection in self.ExtractRelatedConnections(connected):
- self.ConnectionTypes[connection] = "BOOL"
- elif isinstance(instance, plcopen.commonObjects_continuation):
+ for link in connection.getconnections():
+ connected = self.GetLinkedConnector(link, body)
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
+ for related in self.ExtractRelatedConnections(connected):
+ self.ConnectionTypes[related] = "BOOL"
+ elif isinstance(instance, TransitionClass):
+ content = instance.getconditionContent()
+ if content["type"] == "connection":
+ self.ConnectionTypes[content["value"]] = "BOOL"
+ for link in content["value"].getconnections():
+ connected = self.GetLinkedConnector(link, body)
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
+ for related in self.ExtractRelatedConnections(connected):
+ self.ConnectionTypes[related] = "BOOL"
+ elif isinstance(instance, ContinuationClass):
name = instance.getname()
connector = None
var_type = "ANY"
for element in body.getcontentInstances():
- if isinstance(element, plcopen.commonObjects_connector) and element.getname() == name:
+ if isinstance(element, ConnectorClass) and element.getname() == name:
if connector is not None:
raise PLCGenException, _("More than one connector found corresponding to \"%s\" continuation in \"%s\" POU")%(name, self.Name)
connector = element
if connector is not None:
undefined = [instance.connectionPointOut, connector.connectionPointIn]
connected = self.GetConnectedConnector(connector.connectionPointIn, body)
- if connected:
+ if connected is not None:
undefined.append(connected)
related = []
for connection in undefined:
@@ -760,7 +780,7 @@
self.ConnectionTypes[connection] = var_type
else:
raise PLCGenException, _("No connector found corresponding to \"%s\" continuation in \"%s\" POU")%(name, self.Name)
- elif isinstance(instance, plcopen.fbdObjects_block):
+ elif isinstance(instance, BlockClass):
block_infos = self.GetBlockType(instance.gettypeName(), "undefined")
if block_infos is not None:
self.ComputeBlockInputTypes(instance, block_infos, body)
@@ -822,11 +842,11 @@
if not undefined.has_key(itype):
undefined[itype] = []
undefined[itype].append(variable.connectionPointIn)
- if connected:
+ if connected is not None:
undefined[itype].append(connected)
else:
self.ConnectionTypes[variable.connectionPointIn] = itype
- if connected and not self.ConnectionTypes.has_key(connected):
+ if connected is not None and not self.ConnectionTypes.has_key(connected):
for connection in self.ExtractRelatedConnections(connected):
self.ConnectionTypes[connection] = itype
for var_type, connections in undefined.items():
@@ -848,22 +868,22 @@
if isinstance(body, ListType):
body = body[0]
body_content = body.getcontent()
- body_type = body_content["name"]
+ body_type = body_content.getLocalTag()
if body_type in ["IL","ST"]:
- text = body_content["value"].gettext()
+ text = body_content.getanyText()
self.ParentGenerator.GeneratePouProgramInText(text.upper())
self.Program = [(ReIndentText(text, len(self.CurrentIndent)),
(self.TagName, "body", len(self.CurrentIndent)))]
elif body_type == "SFC":
self.IndentRight()
for instance in body.getcontentInstances():
- if isinstance(instance, plcopen.sfcObjects_step):
+ if isinstance(instance, StepClass):
self.GenerateSFCStep(instance, pou)
- elif isinstance(instance, plcopen.commonObjects_actionBlock):
+ elif isinstance(instance, ActionBlockClass):
self.GenerateSFCStepActions(instance, pou)
- elif isinstance(instance, plcopen.sfcObjects_transition):
+ elif isinstance(instance, TransitionClass):
self.GenerateSFCTransition(instance, pou)
- elif isinstance(instance, plcopen.sfcObjects_jumpStep):
+ elif isinstance(instance, JumpStepClass):
self.GenerateSFCJump(instance, pou)
if len(self.InitialSteps) > 0 and len(self.SFCComputedBlocks) > 0:
action_name = "COMPUTE_FUNCTION_BLOCKS"
@@ -878,17 +898,17 @@
otherInstances = {"outVariables&coils" : [], "blocks" : [], "connectors" : []}
orderedInstances = []
for instance in body.getcontentInstances():
- if isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable, plcopen.fbdObjects_block)):
+ if isinstance(instance, (OutVariableClass, InOutVariableClass, BlockClass)):
executionOrderId = instance.getexecutionOrderId()
if executionOrderId > 0:
orderedInstances.append((executionOrderId, instance))
- elif isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
+ elif isinstance(instance, (OutVariableClass, InOutVariableClass)):
otherInstances["outVariables&coils"].append(instance)
- elif isinstance(instance, plcopen.fbdObjects_block):
+ elif isinstance(instance, BlockClass):
otherInstances["blocks"].append(instance)
- elif isinstance(instance, plcopen.commonObjects_connector):
+ elif isinstance(instance, ConnectorClass):
otherInstances["connectors"].append(instance)
- elif isinstance(instance, plcopen.ldObjects_coil):
+ elif isinstance(instance, CoilClass):
otherInstances["outVariables&coils"].append(instance)
orderedInstances.sort()
otherInstances["outVariables&coils"].sort(SortInstances)
@@ -896,17 +916,17 @@
instances = [instance for (executionOrderId, instance) in orderedInstances]
instances.extend(otherInstances["outVariables&coils"] + otherInstances["blocks"] + otherInstances["connectors"])
for instance in instances:
- if isinstance(instance, (plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
+ if isinstance(instance, (OutVariableClass, InOutVariableClass)):
connections = instance.connectionPointIn.getconnections()
if connections is not None:
expression = self.ComputeExpression(body, connections)
if expression is not None:
self.Program += [(self.CurrentIndent, ()),
- (instance.getexpression(), (self.TagName, "io_variable", instance.getlocalId(), "expression")),
+ (instance.getexpression().text, (self.TagName, "io_variable", instance.getlocalId(), "expression")),
(" := ", ())]
self.Program += expression
self.Program += [(";\n", ())]
- elif isinstance(instance, plcopen.fbdObjects_block):
+ elif isinstance(instance, BlockClass):
block_type = instance.gettypeName()
self.ParentGenerator.GeneratePouProgram(block_type)
block_infos = self.GetBlockType(block_type, tuple([self.ConnectionTypes.get(variable.connectionPointIn, "ANY") for variable in instance.inputVariables.getvariable() if variable.getformalParameter() != "EN"]))
@@ -918,14 +938,14 @@
block_infos["generate"](self, instance, block_infos, body, None)
except ValueError, e:
raise PLCGenException, e.message
- elif isinstance(instance, plcopen.commonObjects_connector):
+ elif isinstance(instance, ConnectorClass):
connector = instance.getname()
if self.ComputedConnectors.get(connector, None):
continue
expression = self.ComputeExpression(body, instance.connectionPointIn.getconnections())
if expression is not None:
self.ComputedConnectors[connector] = expression
- elif isinstance(instance, plcopen.ldObjects_coil):
+ elif isinstance(instance, CoilClass):
connections = instance.connectionPointIn.getconnections()
if connections is not None:
coil_info = (self.TagName, "coil", instance.getlocalId())
@@ -933,7 +953,7 @@
if expression is not None:
expression = self.ExtractModifier(instance, expression, coil_info)
self.Program += [(self.CurrentIndent, ())]
- self.Program += [(instance.getvariable(), coil_info + ("reference",))]
+ self.Program += [(instance.getvariable().text, coil_info + ("reference",))]
self.Program += [(" := ", ())] + expression + [(";\n", ())]
def FactorizePaths(self, paths):
@@ -968,11 +988,11 @@
for connection in connections:
localId = connection.getrefLocalId()
next = body.getcontentInstance(localId)
- if isinstance(next, plcopen.ldObjects_leftPowerRail):
+ if isinstance(next, LeftPowerRailClass):
paths.append(None)
- elif isinstance(next, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable)):
- paths.append(str([(next.getexpression(), (self.TagName, "io_variable", localId, "expression"))]))
- elif isinstance(next, plcopen.fbdObjects_block):
+ elif isinstance(next, (InVariableClass, InOutVariableClass)):
+ paths.append(str([(next.getexpression().text, (self.TagName, "io_variable", localId, "expression"))]))
+ elif isinstance(next, BlockClass):
block_type = next.gettypeName()
self.ParentGenerator.GeneratePouProgram(block_type)
block_infos = self.GetBlockType(block_type, tuple([self.ConnectionTypes.get(variable.connectionPointIn, "ANY") for variable in next.inputVariables.getvariable() if variable.getformalParameter() != "EN"]))
@@ -984,7 +1004,7 @@
paths.append(str(block_infos["generate"](self, next, block_infos, body, connection, order, to_inout)))
except ValueError, e:
raise PLCGenException, e.message
- elif isinstance(next, plcopen.commonObjects_continuation):
+ elif isinstance(next, ContinuationClass):
name = next.getname()
computed_value = self.ComputedConnectors.get(name, None)
if computed_value != None:
@@ -992,7 +1012,7 @@
else:
connector = None
for instance in body.getcontentInstances():
- if isinstance(instance, plcopen.commonObjects_connector) and instance.getname() == name:
+ if isinstance(instance, ConnectorClass) and instance.getname() == name:
if connector is not None:
raise PLCGenException, _("More than one connector found corresponding to \"%s\" continuation in \"%s\" POU")%(name, self.Name)
connector = instance
@@ -1005,9 +1025,9 @@
paths.append(str(expression))
else:
raise PLCGenException, _("No connector found corresponding to \"%s\" continuation in \"%s\" POU")%(name, self.Name)
- elif isinstance(next, plcopen.ldObjects_contact):
+ elif isinstance(next, ContactClass):
contact_info = (self.TagName, "contact", next.getlocalId())
- variable = str(self.ExtractModifier(next, [(next.getvariable(), contact_info + ("reference",))], contact_info))
+ variable = str(self.ExtractModifier(next, [(next.getvariable().text, contact_info + ("reference",))], contact_info))
result = self.GeneratePaths(next.connectionPointIn.getconnections(), body, order)
if len(result) > 1:
factorized_paths = self.FactorizePaths(result)
@@ -1021,7 +1041,7 @@
paths.append([variable, result[0]])
else:
paths.append(variable)
- elif isinstance(next, plcopen.ldObjects_coil):
+ elif isinstance(next, CoilClass):
paths.append(str(self.GeneratePaths(next.connectionPointIn.getconnections(), body, order)))
return paths
@@ -1092,7 +1112,7 @@
def ExtractDivergenceInput(self, divergence, pou):
connectionPointIn = divergence.getconnectionPointIn()
- if connectionPointIn:
+ if connectionPointIn is not None:
connections = connectionPointIn.getconnections()
if connections is not None and len(connections) == 1:
instanceLocalId = connections[0].getrefLocalId()
@@ -1124,7 +1144,7 @@
"transitions" : [],
"actions" : []}
self.SFCNetworks["Steps"][step_name] = step_infos
- if step.connectionPointIn:
+ if step.connectionPointIn is not None:
instances = []
connections = step.connectionPointIn.getconnections()
if connections is not None and len(connections) == 1:
@@ -1133,16 +1153,16 @@
if isinstance(body, ListType):
body = body[0]
instance = body.getcontentInstance(instanceLocalId)
- if isinstance(instance, plcopen.sfcObjects_transition):
+ if isinstance(instance, TransitionClass):
instances.append(instance)
- elif isinstance(instance, plcopen.sfcObjects_selectionConvergence):
+ elif isinstance(instance, SelectionConvergenceClass):
instances.extend(self.ExtractConvergenceInputs(instance, pou))
- elif isinstance(instance, plcopen.sfcObjects_simultaneousDivergence):
+ elif isinstance(instance, SimultaneousDivergenceClass):
transition = self.ExtractDivergenceInput(instance, pou)
- if transition:
- if isinstance(transition, plcopen.sfcObjects_transition):
+ if transition is not None:
+ if isinstance(transition, TransitionClass):
instances.append(transition)
- elif isinstance(transition, plcopen.sfcObjects_selectionConvergence):
+ elif isinstance(transition, SelectionConvergenceClass):
instances.extend(self.ExtractConvergenceInputs(transition, pou))
for instance in instances:
self.GenerateSFCTransition(instance, pou)
@@ -1152,7 +1172,7 @@
def GenerateSFCJump(self, jump, pou):
jump_target = jump.gettargetName()
- if jump.connectionPointIn:
+ if jump.connectionPointIn is not None:
instances = []
connections = jump.connectionPointIn.getconnections()
if connections is not None and len(connections) == 1:
@@ -1161,16 +1181,16 @@
if isinstance(body, ListType):
body = body[0]
instance = body.getcontentInstance(instanceLocalId)
- if isinstance(instance, plcopen.sfcObjects_transition):
+ if isinstance(instance, TransitionClass):
instances.append(instance)
- elif isinstance(instance, plcopen.sfcObjects_selectionConvergence):
+ elif isinstance(instance, SelectionConvergenceClass):
instances.extend(self.ExtractConvergenceInputs(instance, pou))
- elif isinstance(instance, plcopen.sfcObjects_simultaneousDivergence):
+ elif isinstance(instance, SimultaneousDivergenceClass):
transition = self.ExtractDivergenceInput(instance, pou)
- if transition:
- if isinstance(transition, plcopen.sfcObjects_transition):
+ if transition is not None:
+ if isinstance(transition, TransitionClass):
instances.append(transition)
- elif isinstance(transition, plcopen.sfcObjects_selectionConvergence):
+ elif isinstance(transition, SelectionConvergenceClass):
instances.extend(self.ExtractConvergenceInputs(transition, pou))
for instance in instances:
self.GenerateSFCTransition(instance, pou)
@@ -1212,7 +1232,7 @@
def GenerateSFCAction(self, action_name, pou):
if action_name not in self.SFCNetworks["Actions"].keys():
actionContent = pou.getaction(action_name)
- if actionContent:
+ if actionContent is not None:
previous_tagname = self.TagName
self.TagName = self.ParentGenerator.Controler.ComputePouActionName(self.Name, action_name)
self.ComputeProgram(actionContent)
@@ -1230,21 +1250,22 @@
if isinstance(body, ListType):
body = body[0]
instance = body.getcontentInstance(instanceLocalId)
- if isinstance(instance, plcopen.sfcObjects_step):
+ if isinstance(instance, StepClass):
steps.append(instance)
- elif isinstance(instance, plcopen.sfcObjects_selectionDivergence):
+ elif isinstance(instance, SelectionDivergenceClass):
step = self.ExtractDivergenceInput(instance, pou)
- if step:
- if isinstance(step, plcopen.sfcObjects_step):
+ if step is not None:
+ if isinstance(step, StepClass):
steps.append(step)
- elif isinstance(step, plcopen.sfcObjects_simultaneousConvergence):
+ elif isinstance(step, SimultaneousConvergenceClass):
steps.extend(self.ExtractConvergenceInputs(step, pou))
- elif isinstance(instance, plcopen.sfcObjects_simultaneousConvergence):
+ elif isinstance(instance, SimultaneousConvergenceClass):
steps.extend(self.ExtractConvergenceInputs(instance, pou))
transition_infos = {"id" : transition.getlocalId(),
"priority": transition.getpriority(),
"from": [],
- "to" : []}
+ "to" : [],
+ "content": []}
self.SFCNetworks["Transitions"][transition] = transition_infos
transitionValues = transition.getconditionContent()
if transitionValues["type"] == "inline":
@@ -1259,14 +1280,14 @@
self.TagName = self.ParentGenerator.Controler.ComputePouTransitionName(self.Name, transitionValues["value"])
if transitionType == "IL":
transition_infos["content"] = [(":\n", ()),
- (ReIndentText(transitionBody.gettext(), len(self.CurrentIndent)), (self.TagName, "body", len(self.CurrentIndent)))]
+ (ReIndentText(transitionBody.getanyText(), len(self.CurrentIndent)), (self.TagName, "body", len(self.CurrentIndent)))]
elif transitionType == "ST":
transition_infos["content"] = [("\n", ()),
- (ReIndentText(transitionBody.gettext(), len(self.CurrentIndent)), (self.TagName, "body", len(self.CurrentIndent)))]
+ (ReIndentText(transitionBody.getanyText(), len(self.CurrentIndent)), (self.TagName, "body", len(self.CurrentIndent)))]
else:
for instance in transitionBody.getcontentInstances():
- if isinstance(instance, plcopen.fbdObjects_outVariable) and instance.getexpression() == transitionValues["value"]\
- or isinstance(instance, plcopen.ldObjects_coil) and instance.getvariable() == transitionValues["value"]:
+ if isinstance(instance, OutVariableClass) and instance.getexpression().text == transitionValues["value"]\
+ or isinstance(instance, CoilClass) and instance.getvariable().text == transitionValues["value"]:
connections = instance.connectionPointIn.getconnections()
if connections is not None:
expression = self.ComputeExpression(transitionBody, connections)
@@ -1281,7 +1302,7 @@
body = pou.getbody()
if isinstance(body, ListType):
body = body[0]
- connections = transition.getconnections()
+ connections = transitionValues["value"].getconnections()
if connections is not None:
expression = self.ComputeExpression(body, connections)
if expression is not None:
@@ -1335,7 +1356,7 @@
action_content, action_info = self.SFCNetworks["Actions"].pop(action_name)
self.Program += [("%sACTION "%self.CurrentIndent, ()),
(action_name, action_info),
- (" :\n", ())]
+ (":\n", ())]
self.Program += action_content
self.Program += [("%sEND_ACTION\n\n"%self.CurrentIndent, ())]
--- a/PLCOpenEditor.py Wed Sep 04 00:06:44 2013 +0200
+++ b/PLCOpenEditor.py Mon Sep 09 00:48:34 2013 +0200
@@ -276,6 +276,7 @@
self.Controler = PLCControler()
self.Controler.CreateNewProject(properties)
self.LibraryPanel.SetController(self.Controler)
+ self.ProjectTree.Enable(True)
self._Refresh(TITLE, FILEMENU, EDITMENU, PROJECTTREE, POUINSTANCEVARIABLESPANEL,
LIBRARYTREE)
--- a/editors/Viewer.py Wed Sep 04 00:06:44 2013 +0200
+++ b/editors/Viewer.py Mon Sep 09 00:48:34 2013 +0200
@@ -1074,7 +1074,7 @@
def RefreshView(self, variablepanel=True, selection=None):
EditorPanel.RefreshView(self, variablepanel)
- if self.TagName.split("::")[0] == "A":
+ if self.TagName.split("::")[0] == "A" and self.Debug:
self.AddDataConsumer("%s.Q" % self.InstancePath.upper(), self)
if self.ToolTipElement is not None:
--- a/plcopen/__init__.py Wed Sep 04 00:06:44 2013 +0200
+++ b/plcopen/__init__.py Mon Sep 09 00:48:34 2013 +0200
@@ -25,9 +25,7 @@
# Package initialisation
# plcopen module dynamically creates its classes
-import plcopen
-for classname, cls in plcopen.PLCOpenClasses.items():
- plcopen.__dict__[classname] = cls
-from plcopen import VarOrder, ElementNameToClass, rect
+from plcopen import PLCOpenParser, LoadProject, SaveProject, LoadPou, \
+ LoadPouInstances, VarOrder, QualifierList, rect
from structures import *
--- a/plcopen/plcopen.py Wed Sep 04 00:06:44 2013 +0200
+++ b/plcopen/plcopen.py Mon Sep 09 00:48:34 2013 +0200
@@ -26,6 +26,7 @@
from structures import *
from types import *
import os, re
+from lxml import etree
from collections import OrderedDict
"""
Dictionary that makes the relation between var names in plcopen and displayed values
@@ -122,14 +123,84 @@
result = criteria["pattern"].search(text, result.end())
return test_result
-PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))
-
-ElementNameToClass = {}
-
-cls = PLCOpenClasses.get("formattedText", None)
+PLCOpenParser = GenerateParserFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))
+PLCOpen_XPath = lambda xpath: etree.XPath(xpath, namespaces=PLCOpenParser.NSMAP)
+
+LOAD_POU_PROJECT_TEMPLATE = """
+<project xmlns:ns1="http://www.plcopen.org/xml/tc6_0201"
+ xmlns:xhtml="http://www.w3.org/1999/xhtml"
+ xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+ xmlns="http://www.plcopen.org/xml/tc6_0201">
+ <fileHeader companyName="" productName="" productVersion=""
+ creationDateTime="1970-01-01T00:00:00"/>
+ <contentHeader name="paste_project">
+ <coordinateInfo>
+ <fbd><scaling x="0" y="0"/></fbd>
+ <ld><scaling x="0" y="0"/></ld>
+ <sfc><scaling x="0" y="0"/></sfc>
+ </coordinateInfo>
+ </contentHeader>
+ <types>
+ <dataTypes/>
+ <pous>%s</pous>
+ </types>
+ <instances>
+ <configurations/>
+ </instances>
+</project>
+"""
+
+def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):
+ return LOAD_POU_PROJECT_TEMPLATE % """
+<pou name="paste_pou" pouType="program">
+ <body>
+ <%(body_type)s>%%s</%(body_type)s>
+ </body>
+</pou>""" % locals()
+
+def LoadProject(filepath):
+ project_file = open(filepath)
+ project_xml = project_file.read().replace(
+ "http://www.plcopen.org/xml/tc6.xsd",
+ "http://www.plcopen.org/xml/tc6_0201")
+ for cre, repl in [
+ (re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),
+ (re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:
+ project_xml = cre.sub(repl, project_xml)
+ project_file.close()
+
+ return etree.fromstring(project_xml, PLCOpenParser)
+
+project_pou_xpath = PLCOpen_XPath("/ppx:project/ppx:types/ppx:pous/ppx:pou")
+def LoadPou(xml_string):
+ root = etree.fromstring(
+ LOAD_POU_PROJECT_TEMPLATE % xml_string,
+ PLCOpenParser)
+ return project_pou_xpath(root)[0]
+
+project_pou_instances_xpath = {
+ body_type: PLCOpen_XPath(
+ "/ppx:project/ppx:types/ppx:pous/ppx:pou[@name='paste_pou']/ppx:body/ppx:%s/*" % body_type)
+ for body_type in ["FBD", "LD", "SFC"]}
+def LoadPouInstances(xml_string, body_type):
+ root = etree.fromstring(
+ LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string,
+ PLCOpenParser)
+ return project_pou_instances_xpath[body_type](root)
+
+def SaveProject(project, filepath):
+ project_file = open(filepath, 'w')
+ project_file.write(etree.tostring(
+ project,
+ pretty_print=True,
+ xml_declaration=True,
+ encoding='utf-8'))
+ project_file.close()
+
+cls = PLCOpenParser.GetElementClass("formattedText")
if cls:
def updateElementName(self, old_name, new_name):
- text = self.text
+ text = self.getanyText()
index = text.find(old_name)
while index != -1:
if index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_"):
@@ -139,11 +210,11 @@
else:
text = text[:index] + new_name + text[index + len(old_name):]
index = text.find(old_name, index + len(new_name))
- self.text = text
+ self.setanyText(text)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- text = self.text
+ text = self.getanyText()
startpos = 0
result = address_model.search(text, startpos)
while result is not None:
@@ -152,11 +223,11 @@
text = text[:result.start()] + new_address + text[result.end():]
startpos = result.start() + len(new_address)
result = address_model.search(self.text, startpos)
- self.text = text
+ self.setanyText(text)
setattr(cls, "updateElementAddress", updateElementAddress)
def hasblock(self, block_type):
- text = self.text.upper()
+ text = self.getanyText().upper()
index = text.find(block_type.upper())
while index != -1:
if (not (index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_")) and
@@ -167,17 +238,11 @@
setattr(cls, "hasblock", hasblock)
def Search(self, criteria, parent_infos):
- return [(tuple(parent_infos),) + result for result in TestTextElement(self.gettext(), criteria)]
+ return [(tuple(parent_infos),) + result for result in TestTextElement(self.getanyText(), criteria)]
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("project", None)
-if cls:
- cls.singleLineAttributes = False
- cls.EnumeratedDataTypeValues = {}
- cls.CustomDataTypeRange = {}
- cls.CustomTypeHierarchy = {}
- cls.ElementUsingTree = {}
- cls.CustomBlockTypes = OrderedDict()
+cls = PLCOpenParser.GetElementClass("project")
+if cls:
def setname(self, name):
self.contentHeader.setname(name)
@@ -188,522 +253,216 @@
setattr(cls, "getname", getname)
def getfileHeader(self):
- fileheader = {}
- for name, value in [("companyName", self.fileHeader.getcompanyName()),
- ("companyURL", self.fileHeader.getcompanyURL()),
- ("productName", self.fileHeader.getproductName()),
- ("productVersion", self.fileHeader.getproductVersion()),
- ("productRelease", self.fileHeader.getproductRelease()),
- ("creationDateTime", self.fileHeader.getcreationDateTime()),
- ("contentDescription", self.fileHeader.getcontentDescription())]:
- if value is not None:
- fileheader[name] = value
- else:
- fileheader[name] = ""
- return fileheader
+ fileheader_obj = self.fileHeader
+ return {
+ attr: value if value is not None else ""
+ for attr, value in [
+ ("companyName", fileheader_obj.getcompanyName()),
+ ("companyURL", fileheader_obj.getcompanyURL()),
+ ("productName", fileheader_obj.getproductName()),
+ ("productVersion", fileheader_obj.getproductVersion()),
+ ("productRelease", fileheader_obj.getproductRelease()),
+ ("creationDateTime", fileheader_obj.getcreationDateTime()),
+ ("contentDescription", fileheader_obj.getcontentDescription())]
+ }
setattr(cls, "getfileHeader", getfileHeader)
def setfileHeader(self, fileheader):
- if fileheader.has_key("companyName"):
- self.fileHeader.setcompanyName(fileheader["companyName"])
- if fileheader.has_key("companyURL"):
- self.fileHeader.setcompanyURL(fileheader["companyURL"])
- if fileheader.has_key("productName"):
- self.fileHeader.setproductName(fileheader["productName"])
- if fileheader.has_key("productVersion"):
- self.fileHeader.setproductVersion(fileheader["productVersion"])
- if fileheader.has_key("productRelease"):
- self.fileHeader.setproductRelease(fileheader["productRelease"])
- if fileheader.has_key("creationDateTime"):
- self.fileHeader.setcreationDateTime(fileheader["creationDateTime"])
- if fileheader.has_key("contentDescription"):
- self.fileHeader.setcontentDescription(fileheader["contentDescription"])
+ fileheader_obj = self.fileHeader
+ for attr, value in fileheader.iteritems():
+ setattr(fileheader_obj, attr, value)
setattr(cls, "setfileHeader", setfileHeader)
def getcontentHeader(self):
- contentheader = {}
- for name, value in [("projectName", self.contentHeader.getname()),
- ("projectVersion", self.contentHeader.getversion()),
- ("modificationDateTime", self.contentHeader.getmodificationDateTime()),
- ("organization", self.contentHeader.getorganization()),
- ("authorName", self.contentHeader.getauthor()),
- ("language", self.contentHeader.getlanguage())]:
- if value is not None:
- contentheader[name] = value
- else:
- contentheader[name] = ""
+ contentheader_obj = self.contentHeader
+ contentheader = {
+ attr: value if value is not None else ""
+ for attr, value in [
+ ("projectName", contentheader_obj.getname()),
+ ("projectVersion", contentheader_obj.getversion()),
+ ("modificationDateTime", contentheader_obj.getmodificationDateTime()),
+ ("organization", contentheader_obj.getorganization()),
+ ("authorName", contentheader_obj.getauthor()),
+ ("language", contentheader_obj.getlanguage())]
+ }
contentheader["pageSize"] = self.contentHeader.getpageSize()
contentheader["scaling"] = self.contentHeader.getscaling()
return contentheader
setattr(cls, "getcontentHeader", getcontentHeader)
def setcontentHeader(self, contentheader):
- if contentheader.has_key("projectName"):
- self.contentHeader.setname(contentheader["projectName"])
- if contentheader.has_key("projectVersion"):
- self.contentHeader.setversion(contentheader["projectVersion"])
- if contentheader.has_key("modificationDateTime"):
- self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"])
- if contentheader.has_key("organization"):
- self.contentHeader.setorganization(contentheader["organization"])
- if contentheader.has_key("authorName"):
- self.contentHeader.setauthor(contentheader["authorName"])
- if contentheader.has_key("language"):
- self.contentHeader.setlanguage(contentheader["language"])
- if contentheader.has_key("pageSize"):
- self.contentHeader.setpageSize(*contentheader["pageSize"])
- if contentheader.has_key("scaling"):
- self.contentHeader.setscaling(contentheader["scaling"])
+ contentheader_obj = self.contentHeader
+ for attr, value in contentheader.iteritems():
+ if attr == "projectName":
+ contentheader_obj.setname(value)
+ elif attr == "projectVersion":
+ contentheader_obj.setversion(value)
+ elif attr == "pageSize":
+ contentheader_obj.setpageSize(*contentheader["pageSize"])
+ elif attr == "scaling":
+ contentheader_obj.setscaling(contentheader["scaling"])
+ else:
+ setattr(contentheader_obj, attr, value)
setattr(cls, "setcontentHeader", setcontentHeader)
- def getdataTypes(self):
- return self.types.getdataTypeElements()
+ def gettypeElementFunc(element_type):
+ elements_xpath = PLCOpen_XPath(
+ "ppx:types/ppx:%(element_type)ss/ppx:%(element_type)s[@name=$name]" % locals())
+ def gettypeElement(self, name):
+ elements = elements_xpath(self, name=name)
+ if len(elements) == 1:
+ return elements[0]
+ return None
+ return gettypeElement
+
+ datatypes_xpath = PLCOpen_XPath("ppx:types/ppx:dataTypes/ppx:dataType")
+ filtered_datatypes_xpath = PLCOpen_XPath(
+ "ppx:types/ppx:dataTypes/ppx:dataType[@name!=$exclude]")
+ def getdataTypes(self, exclude=None):
+ if exclude is not None:
+ return filtered_datatypes_xpath(self, exclude=exclude)
+ return datatypes_xpath(self)
setattr(cls, "getdataTypes", getdataTypes)
- def getdataType(self, name):
- return self.types.getdataTypeElement(name)
- setattr(cls, "getdataType", getdataType)
+ setattr(cls, "getdataType", gettypeElementFunc("dataType"))
def appenddataType(self, name):
- if self.CustomTypeHierarchy.has_key(name):
+ if self.getdataType(name) is not None:
raise ValueError, "\"%s\" Data Type already exists !!!"%name
self.types.appenddataTypeElement(name)
- self.AddCustomDataType(self.getdataType(name))
setattr(cls, "appenddataType", appenddataType)
def insertdataType(self, index, datatype):
self.types.insertdataTypeElement(index, datatype)
- self.AddCustomDataType(datatype)
setattr(cls, "insertdataType", insertdataType)
def removedataType(self, name):
self.types.removedataTypeElement(name)
- self.RefreshDataTypeHierarchy()
- self.RefreshElementUsingTree()
setattr(cls, "removedataType", removedataType)
- def getpous(self):
- return self.types.getpouElements()
+ def getpous(self, exclude=None, filter=[]):
+ return self.xpath(
+ "ppx:types/ppx:pous/ppx:pou%s%s" %
+ (("[@name!='%s']" % exclude) if exclude is not None else '',
+ ("[%s]" % " or ".join(
+ map(lambda x: "@pouType='%s'" % x, filter)))
+ if len(filter) > 0 else ""),
+ namespaces=PLCOpenParser.NSMAP)
setattr(cls, "getpous", getpous)
- def getpou(self, name):
- return self.types.getpouElement(name)
- setattr(cls, "getpou", getpou)
+ setattr(cls, "getpou", gettypeElementFunc("pou"))
def appendpou(self, name, pou_type, body_type):
self.types.appendpouElement(name, pou_type, body_type)
- self.AddCustomBlockType(self.getpou(name))
setattr(cls, "appendpou", appendpou)
def insertpou(self, index, pou):
self.types.insertpouElement(index, pou)
- self.AddCustomBlockType(pou)
setattr(cls, "insertpou", insertpou)
def removepou(self, name):
self.types.removepouElement(name)
- self.RefreshCustomBlockTypes()
- self.RefreshElementUsingTree()
setattr(cls, "removepou", removepou)
+ configurations_xpath = PLCOpen_XPath(
+ "ppx:instances/ppx:configurations/ppx:configuration")
def getconfigurations(self):
- configurations = self.instances.configurations.getconfiguration()
- if configurations:
- return configurations
- return []
+ return configurations_xpath(self)
setattr(cls, "getconfigurations", getconfigurations)
+ configuration_xpath = PLCOpen_XPath(
+ "ppx:instances/ppx:configurations/ppx:configuration[@name=$name]")
def getconfiguration(self, name):
- for configuration in self.instances.configurations.getconfiguration():
- if configuration.getname() == name:
- return configuration
+ configurations = configuration_xpath(self, name=name)
+ if len(configurations) == 1:
+ return configurations[0]
return None
setattr(cls, "getconfiguration", getconfiguration)
def addconfiguration(self, name):
- for configuration in self.instances.configurations.getconfiguration():
- if configuration.getname() == name:
- raise ValueError, _("\"%s\" configuration already exists !!!")%name
- new_configuration = PLCOpenClasses["configurations_configuration"]()
+ if self.getconfiguration(name) is not None:
+ raise ValueError, _("\"%s\" configuration already exists !!!") % name
+ new_configuration = PLCOpenParser.CreateElement("configuration", "configurations")
new_configuration.setname(name)
self.instances.configurations.appendconfiguration(new_configuration)
setattr(cls, "addconfiguration", addconfiguration)
def removeconfiguration(self, name):
- found = False
- for idx, configuration in enumerate(self.instances.configurations.getconfiguration()):
- if configuration.getname() == name:
- self.instances.configurations.removeconfiguration(idx)
- found = True
- break
- if not found:
- raise ValueError, ("\"%s\" configuration doesn't exist !!!")%name
+ configuration = self.getconfiguration(name)
+ if configuration is None:
+ raise ValueError, ("\"%s\" configuration doesn't exist !!!") % name
+ self.instances.configurations.remove(configuration)
setattr(cls, "removeconfiguration", removeconfiguration)
-
+
+ resources_xpath = PLCOpen_XPath(
+ "ppx:instances/ppx:configurations/ppx:configuration[@name=$configname]/ppx:resource[@name=$name]")
def getconfigurationResource(self, config_name, name):
- configuration = self.getconfiguration(config_name)
- if configuration:
- for resource in configuration.getresource():
- if resource.getname() == name:
- return resource
+ resources = resources_xpath(self, configname=config_name, name=name)
+ if len(resources) == 1:
+ return resources[0]
return None
setattr(cls, "getconfigurationResource", getconfigurationResource)
def addconfigurationResource(self, config_name, name):
+ if self.getconfigurationResource(config_name, name) is not None:
+ raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!") % (name, config_name)
configuration = self.getconfiguration(config_name)
- if configuration:
- for resource in configuration.getresource():
- if resource.getname() == name:
- raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name)
- new_resource = PLCOpenClasses["configuration_resource"]()
+ if configuration is not None:
+ new_resource = PLCOpenParser.CreateElement("resource", "configuration")
new_resource.setname(name)
configuration.appendresource(new_resource)
setattr(cls, "addconfigurationResource", addconfigurationResource)
def removeconfigurationResource(self, config_name, name):
configuration = self.getconfiguration(config_name)
- if configuration:
- found = False
- for idx, resource in enumerate(configuration.getresource()):
- if resource.getname() == name:
- configuration.removeresource(idx)
- found = True
- break
- if not found:
- raise ValueError, _("\"%s\" resource doesn't exist in \"%s\" configuration !!!")%(name, config_name)
+ found = False
+ if configuration is not None:
+ resource = self.getconfigurationResource(config_name, name)
+ if resource is not None:
+ configuration.remove(resource)
+ found = True
+ if not found:
+ raise ValueError, _("\"%s\" resource doesn't exist in \"%s\" configuration !!!")%(name, config_name)
setattr(cls, "removeconfigurationResource", removeconfigurationResource)
def updateElementName(self, old_name, new_name):
- for datatype in self.types.getdataTypeElements():
+ for datatype in self.getdataTypes():
datatype.updateElementName(old_name, new_name)
- for pou in self.types.getpouElements():
+ for pou in self.getpous():
pou.updateElementName(old_name, new_name)
- for configuration in self.instances.configurations.getconfiguration():
+ for configuration in self.getconfigurations():
configuration.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, old_leading, new_leading):
address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)
- for pou in self.types.getpouElements():
+ for pou in self.getpous():
pou.updateElementAddress(address_model, new_leading)
- for configuration in self.instances.configurations.getconfiguration():
+ for configuration in self.getconfigurations():
configuration.updateElementAddress(address_model, new_leading)
setattr(cls, "updateElementAddress", updateElementAddress)
def removeVariableByAddress(self, address):
- for pou in self.types.getpouElements():
+ for pou in self.getpous():
pou.removeVariableByAddress(address)
- for configuration in self.instances.configurations.getconfiguration():
+ for configuration in self.getconfigurations():
configuration.removeVariableByAddress(address)
setattr(cls, "removeVariableByAddress", removeVariableByAddress)
def removeVariableByFilter(self, leading):
address_model = re.compile(FILTER_ADDRESS_MODEL % leading)
- for pou in self.types.getpouElements():
+ for pou in self.getpous():
pou.removeVariableByFilter(address_model)
- for configuration in self.instances.configurations.getconfiguration():
+ for configuration in self.getconfigurations():
configuration.removeVariableByFilter(address_model)
setattr(cls, "removeVariableByFilter", removeVariableByFilter)
- def RefreshDataTypeHierarchy(self):
- self.EnumeratedDataTypeValues = {}
- self.CustomDataTypeRange = {}
- self.CustomTypeHierarchy = {}
- for datatype in self.getdataTypes():
- self.AddCustomDataType(datatype)
- setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)
-
- def AddCustomDataType(self, datatype):
- name = datatype.getname()
- basetype_content = datatype.getbaseType().getcontent()
- if basetype_content["value"] is None:
- self.CustomTypeHierarchy[name] = basetype_content["name"]
- elif basetype_content["name"] in ["string", "wstring"]:
- self.CustomTypeHierarchy[name] = basetype_content["name"].upper()
- elif basetype_content["name"] == "derived":
- self.CustomTypeHierarchy[name] = basetype_content["value"].getname()
- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
- range = (basetype_content["value"].range.getlower(),
- basetype_content["value"].range.getupper())
- self.CustomDataTypeRange[name] = range
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["value"] is None:
- self.CustomTypeHierarchy[name] = base_type["name"]
- else:
- self.CustomTypeHierarchy[name] = base_type["value"].getname()
- else:
- if basetype_content["name"] == "enum":
- values = []
- for value in basetype_content["value"].values.getvalue():
- values.append(value.getname())
- self.EnumeratedDataTypeValues[name] = values
- self.CustomTypeHierarchy[name] = "ANY_DERIVED"
- setattr(cls, "AddCustomDataType", AddCustomDataType)
-
- # Update Block types with user-defined pou added
- def RefreshCustomBlockTypes(self):
- # Reset the tree of user-defined pou cross-use
- self.CustomBlockTypes = OrderedDict()
- for pou in self.getpous():
- self.AddCustomBlockType(pou)
- setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)
-
- def AddCustomBlockType(self, pou):
- pou_name = pou.getname()
- pou_type = pou.getpouType()
- block_infos = {"name" : pou_name, "type" : pou_type, "extensible" : False,
- "inputs" : [], "outputs" : [], "comment" : pou.getdescription(),
- "generate" : generate_block, "initialise" : initialise_block}
- if pou.getinterface():
- return_type = pou.interface.getreturnType()
- if return_type:
- var_type = return_type.getcontent()
- if var_type["name"] == "derived":
- block_infos["outputs"].append(("OUT", var_type["value"].getname(), "none"))
- elif var_type["name"] in ["string", "wstring"]:
- block_infos["outputs"].append(("OUT", var_type["name"].upper(), "none"))
- else:
- block_infos["outputs"].append(("OUT", var_type["name"], "none"))
- for type, varlist in pou.getvars():
- if type == "InOut":
- for var in varlist.getvariable():
- var_type = var.type.getcontent()
- if var_type["name"] == "derived":
- block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))
- block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))
- elif var_type["name"] in ["string", "wstring"]:
- block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))
- block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))
- else:
- block_infos["inputs"].append((var.getname(), var_type["name"], "none"))
- block_infos["outputs"].append((var.getname(), var_type["name"], "none"))
- elif type == "Input":
- for var in varlist.getvariable():
- var_type = var.type.getcontent()
- if var_type["name"] == "derived":
- block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))
- elif var_type["name"] in ["string", "wstring"]:
- block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))
- else:
- block_infos["inputs"].append((var.getname(), var_type["name"], "none"))
- elif type == "Output":
- for var in varlist.getvariable():
- var_type = var.type.getcontent()
- if var_type["name"] == "derived":
- block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))
- elif var_type["name"] in ["string", "wstring"]:
- block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))
- else:
- block_infos["outputs"].append((var.getname(), var_type["name"], "none"))
- block_infos["usage"] = "\n (%s) => (%s)" % (", ".join(["%s:%s" % (input[1], input[0]) for input in block_infos["inputs"]]),
- ", ".join(["%s:%s" % (output[1], output[0]) for output in block_infos["outputs"]]))
- self.CustomBlockTypes[pou_name]=block_infos
- setattr(cls, "AddCustomBlockType", AddCustomBlockType)
-
- def AddElementUsingTreeInstance(self, name, type_infos):
- typename = type_infos.getname()
- elements = self.ElementUsingTree.setdefault(typename, set())
- elements.add(name)
- setattr(cls, "AddElementUsingTreeInstance", AddElementUsingTreeInstance)
-
- def RefreshElementUsingTree(self):
- # Reset the tree of user-defined element cross-use
- self.ElementUsingTree = {}
- pous = self.getpous()
- datatypes = self.getdataTypes()
- # Analyze each datatype
- for datatype in datatypes:
- name = datatype.getname()
- basetype_content = datatype.baseType.getcontent()
- if basetype_content["name"] == "derived":
- self.AddElementUsingTreeInstance(name,
- basetype_content["value"])
- elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]:
- base_type = basetype_content["value"].baseType.getcontent()
- if base_type["name"] == "derived":
- self.AddElementUsingTreeInstance(name, base_type["value"])
- elif basetype_content["name"] == "struct":
- for element in basetype_content["value"].getvariable():
- type_content = element.type.getcontent()
- if type_content["name"] == "derived":
- self.AddElementUsingTreeInstance(name, type_content["value"])
- # Analyze each pou
- for pou in pous:
- name = pou.getname()
- if pou.interface:
- # Extract variables from every varLists
- for type, varlist in pou.getvars():
- for var in varlist.getvariable():
- vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived":
- self.AddElementUsingTreeInstance(name, vartype_content["value"])
-
- setattr(cls, "RefreshElementUsingTree", RefreshElementUsingTree)
-
- def GetParentType(self, type):
- if self.CustomTypeHierarchy.has_key(type):
- return self.CustomTypeHierarchy[type]
- elif TypeHierarchy.has_key(type):
- return TypeHierarchy[type]
- return None
- setattr(cls, "GetParentType", GetParentType)
-
- def GetBaseType(self, type):
- parent_type = self.GetParentType(type)
- if parent_type is not None:
- if parent_type.startswith("ANY"):
- return type
- else:
- return self.GetBaseType(parent_type)
- return None
- setattr(cls, "GetBaseType", GetBaseType)
-
- def GetSubrangeBaseTypes(self, exclude):
- derived = []
- for type in self.CustomTypeHierarchy.keys():
- for base_type in DataTypeRange.keys():
- if self.IsOfType(type, base_type) and not self.IsOfType(type, exclude):
- derived.append(type)
- break
- return derived
- setattr(cls, "GetSubrangeBaseTypes", GetSubrangeBaseTypes)
-
- """
- returns true if the given data type is the same that "reference" meta-type or one of its types.
- """
- def IsOfType(self, type, reference):
- if reference is None:
- return True
- elif type == reference:
- return True
- else:
- parent_type = self.GetParentType(type)
- if parent_type is not None:
- return self.IsOfType(parent_type, reference)
- return False
- setattr(cls, "IsOfType", IsOfType)
-
- # Return if pou given by name is used by another pou
- def ElementIsUsed(self, name):
- elements = self.ElementUsingTree.get(name, None)
- return elements is not None
- setattr(cls, "ElementIsUsed", ElementIsUsed)
-
- def DataTypeIsDerived(self, name):
- return name in self.CustomTypeHierarchy.values()
- setattr(cls, "DataTypeIsDerived", DataTypeIsDerived)
-
- # Return if pou given by name is directly or undirectly used by the reference pou
- def ElementIsUsedBy(self, name, reference):
- elements = self.ElementUsingTree.get(name, set())
- # Test if pou is directly used by reference
- if reference in elements:
- return True
- else:
- # Test if pou is undirectly used by reference, by testing if pous
- # that directly use pou is directly or undirectly used by reference
- selffn = self.ElementIsUsedBy
- for element in elements:
- if selffn(element, reference):
- return True
- return False
- setattr(cls, "ElementIsUsedBy", ElementIsUsedBy)
-
- def GetDataTypeRange(self, type):
- if self.CustomDataTypeRange.has_key(type):
- return self.CustomDataTypeRange[type]
- elif DataTypeRange.has_key(type):
- return DataTypeRange[type]
- else:
- parent_type = self.GetParentType(type)
- if parent_type is not None:
- return self.GetDataTypeRange(parent_type)
- return None
- setattr(cls, "GetDataTypeRange", GetDataTypeRange)
-
- def GetEnumeratedDataTypeValues(self, type = None):
- if type is None:
- all_values = []
- for values in self.EnumeratedDataTypeValues.values():
- all_values.extend(values)
- return all_values
- elif self.EnumeratedDataTypeValues.has_key(type):
- return self.EnumeratedDataTypeValues[type]
- return []
+ enumerated_values_xpath = PLCOpen_XPath(
+ "ppx:types/ppx:dataTypes/ppx:dataType/ppx:baseType/ppx:enum/ppx:values/ppx:value")
+ def GetEnumeratedDataTypeValues(self):
+ return [value.getname() for value in enumerated_values_xpath(self)]
setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues)
- # Function that returns the block definition associated to the block type given
- def GetCustomBlockType(self, typename, inputs = None):
- customblocktype = self.CustomBlockTypes.get(typename,None)
- if customblocktype is not None:
- if inputs is not None and inputs != "undefined":
- customblock_inputs = tuple([var_type for name, var_type, modifier in customblocktype["inputs"]])
- if inputs == customblock_inputs:
- return customblocktype
- else:
- return customblocktype
- return None
- setattr(cls, "GetCustomBlockType", GetCustomBlockType)
-
- # Return Block types checking for recursion
- def GetCustomBlockTypes(self, exclude = None, onlyfunctions = False):
- if exclude is not None:
- return [customblocktype for name,customblocktype in self.CustomBlockTypes.iteritems()
- if (customblocktype["type"] != "program"
- and name != exclude
- and not self.ElementIsUsedBy(exclude, name)
- and not (onlyfunctions and customblocktype["type"] != "function"))]
- return [customblocktype for customblocktype in self.CustomBlockTypes.itervalues()
- if (customblocktype["type"] != "program"
- and not (onlyfunctions and customblocktype["type"] != "function"))]
- setattr(cls, "GetCustomBlockTypes", GetCustomBlockTypes)
-
- # Return Function Block types checking for recursion
- def GetCustomFunctionBlockTypes(self, exclude = None):
- if exclude is not None:
- return [customblocktype for name,customblocktype in self.CustomBlockTypes.iteritems()
- if (customblocktype["type"] == "functionBlock"
- and name != exclude
- and not self.ElementIsUsedBy(exclude, name))]
- return [customblocktype for customblocktype in self.CustomBlockTypes.itervalues()
- if customblocktype["type"] == "functionBlock"]
- setattr(cls, "GetCustomFunctionBlockTypes", GetCustomFunctionBlockTypes)
-
- # Return Block types checking for recursion
- def GetCustomBlockResource(self):
- return [customblocktype["name"] for customblocktype in self.CustomBlockTypes.itervalues()
- if customblocktype["type"] == "program"]
- setattr(cls, "GetCustomBlockResource", GetCustomBlockResource)
-
- # Return Data Types checking for recursion
- def GetCustomDataTypes(self, exclude = "", only_locatable = False):
- customdatatypes = []
- for customdatatype in self.getdataTypes():
- if not only_locatable or self.IsLocatableType(customdatatype):
- customdatatype_name = customdatatype.getname()
- if customdatatype_name != exclude and not self.ElementIsUsedBy(exclude, customdatatype_name):
- customdatatypes.append({"name": customdatatype_name, "infos": customdatatype})
- return customdatatypes
- setattr(cls, "GetCustomDataTypes", GetCustomDataTypes)
-
- # Return if Data Type can be used for located variables
- def IsLocatableType(self, datatype):
- basetype_content = datatype.baseType.getcontent()
- if basetype_content["name"] in ["enum", "struct"]:
- return False
- elif basetype_content["name"] == "derived":
- base_type = self.getdataType(basetype_content["value"].getname())
- if base_type is not None:
- return self.IsLocatableType(base_type)
- elif basetype_content["name"] == "array":
- array_base_type = basetype_content["value"].baseType.getcontent()
- if array_base_type["value"] is not None and array_base_type["name"] not in ["string", "wstring"]:
- base_type = self.getdataType(array_base_type["value"].getname())
- if base_type is not None:
- return self.IsLocatableType(base_type)
- return True
- setattr(cls, "IsLocatableType", IsLocatableType)
-
def Search(self, criteria, parent_infos=[]):
result = self.types.Search(criteria, parent_infos)
for configuration in self.instances.configurations.getconfiguration():
@@ -711,13 +470,8 @@
return result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("project_fileHeader", None)
-if cls:
- cls.singleLineAttributes = False
-
-cls = PLCOpenClasses.get("project_contentHeader", None)
-if cls:
- cls.singleLineAttributes = False
+cls = PLCOpenParser.GetElementClass("contentHeader", "project")
+if cls:
def setpageSize(self, width, height):
self.coordinateInfo.setpageSize(width, height)
@@ -740,7 +494,7 @@
return scaling
setattr(cls, "getscaling", getscaling)
-cls = PLCOpenClasses.get("contentHeader_coordinateInfo", None)
+cls = PLCOpenParser.GetElementClass("coordinateInfo", "contentHeader")
if cls:
def setpageSize(self, width, height):
if width == 0 and height == 0:
@@ -809,7 +563,7 @@
variables = varlist.getvariable()
for i in xrange(len(variables)-1, -1, -1):
if variables[i].getaddress() == address:
- variables.pop(i)
+ variables.remove(variables[i])
def _removeConfigurationResourceVariableByFilter(self, address_model):
for varlist in self.getglobalVars():
@@ -819,7 +573,7 @@
if var_address is not None:
result = address_model.match(var_address)
if result is not None:
- variables.pop(i)
+ variables.remove(variables[i])
def _SearchInConfigurationResource(self, criteria, parent_infos=[]):
search_result = _Search([("name", self.getname())], criteria, parent_infos)
@@ -839,33 +593,30 @@
var_number += 1
return search_result
-cls = PLCOpenClasses.get("configurations_configuration", None)
-if cls:
-
- def addglobalVar(self, type, name, location="", description=""):
+cls = PLCOpenParser.GetElementClass("configuration", "configurations")
+if cls:
+
+ def addglobalVar(self, var_type, name, location="", description=""):
globalvars = self.getglobalVars()
if len(globalvars) == 0:
- globalvars.append(PLCOpenClasses["varList"]())
- var = PLCOpenClasses["varListPlain_variable"]()
+ globalvars.append(PLCOpenParser.CreateElement("varList"))
+ var = PLCOpenParser.CreateElement("variable", "varListPlain")
var.setname(name)
- var_type = PLCOpenClasses["dataType"]()
- if type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:
- if type == "STRING":
- var_type.setcontent({"name" : "string", "value" : PLCOpenClasses["elementaryTypes_string"]()})
- elif type == "WSTRING":
- var_type.setcontent({"name" : "wstring", "value" : PLCOpenClasses["elementaryTypes_wstring"]()})
- else:
- var_type.setcontent({"name" : type, "value" : None})
+ var_type_obj = PLCOpenParser.CreateElement("dataType")
+ if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:
+ var_type_obj.setcontent(PLCOpenParser.CreateElement(
+ var_type.lower() if var_type in ["STRING", "WSTRING"]
+ else vartype, "dataType"))
else:
- derived_type = PLCOpenClasses["derivedTypes_derived"]()
- derived_type.setname(type)
- var_type.setcontent({"name" : "derived", "value" : derived_type})
- var.settype(var_type)
+ derived_type = PLCOpenParser.CreateElement("derived", "dataType")
+ derived_type.setname(var_type)
+ var_type_obj.setcontent(derived_type)
+ var.settype(var_type_obj)
if location != "":
var.setaddress(location)
if description != "":
- ft = PLCOpenClasses["formattedText"]()
- ft.settext(description)
+ ft = PLCOpenParser.CreateElement("documentation", "variable")
+ ft.setanyText(description)
var.setdocumentation(ft)
globalvars[-1].appendvariable(var)
setattr(cls, "addglobalVar", addglobalVar)
@@ -896,7 +647,7 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("configuration_resource", None)
+cls = PLCOpenParser.GetElementClass("resource", "configuration")
if cls:
def updateElementName(self, old_name, new_name):
_updateConfigurationResourceElementName(self, old_name, new_name)
@@ -937,7 +688,7 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("resource_task", None)
+cls = PLCOpenParser.GetElementClass("task", "resource")
if cls:
def compatibility(self, tree):
if tree.hasAttribute("interval"):
@@ -986,7 +737,7 @@
criteria, parent_infos)
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("pouInstance", None)
+cls = PLCOpenParser.GetElementClass("pouInstance")
if cls:
def compatibility(self, tree):
if tree.hasAttribute("type"):
@@ -1004,31 +755,33 @@
criteria, parent_infos)
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("varListPlain_variable", None)
+cls = PLCOpenParser.GetElementClass("variable", "varListPlain")
if cls:
def gettypeAsText(self):
vartype_content = self.gettype().getcontent()
+ vartype_content_name = vartype_content.getLocalTag()
# Variable type is a user data type
- if vartype_content["name"] == "derived":
- return vartype_content["value"].getname()
+ if vartype_content_name == "derived":
+ return vartype_content.getname()
# Variable type is a string type
- elif vartype_content["name"] in ["string", "wstring"]:
- return vartype_content["name"].upper()
+ elif vartype_content_name in ["string", "wstring"]:
+ return vartype_content_name.upper()
# Variable type is an array
- elif vartype_content["name"] == "array":
- base_type = vartype_content["value"].baseType.getcontent()
+ elif vartype_content_name == "array":
+ base_type = vartype_content.baseType.getcontent()
+ base_type_name = base_type.getLocalTag()
# Array derived directly from a user defined type
- if base_type["name"] == "derived":
- basetype_name = base_type["value"].getname()
+ if base_type_name == "derived":
+ basetype_name = base_type.getname()
# Array derived directly from a string type
- elif base_type["name"] in ["string", "wstring"]:
- basetype_name = base_type["name"].upper()
+ elif base_type_name in ["string", "wstring"]:
+ basetype_name = base_type_name.upper()
# Array derived directly from an elementary type
else:
- basetype_name = base_type["name"]
- return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content["value"].getdimension())), basetype_name)
+ basetype_name = base_type_name
+ return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content.getdimension())), basetype_name)
# Variable type is an elementary type
- return vartype_content["name"]
+ return vartype_content_name
setattr(cls, "gettypeAsText", gettypeAsText)
def Search(self, criteria, parent_infos=[]):
@@ -1045,7 +798,7 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("project_types", None)
+cls = PLCOpenParser.GetElementClass("types", "project")
if cls:
def getdataTypeElements(self):
return self.dataTypes.getdataType()
@@ -1060,10 +813,10 @@
setattr(cls, "getdataTypeElement", getdataTypeElement)
def appenddataTypeElement(self, name):
- new_datatype = PLCOpenClasses["dataTypes_dataType"]()
+ new_datatype = PLCOpenParser.CreateElement("dataType", "dataTypes")
+ self.dataTypes.appenddataType(new_datatype)
new_datatype.setname(name)
- new_datatype.baseType.setcontent({"name" : "BOOL", "value" : None})
- self.dataTypes.appenddataType(new_datatype)
+ new_datatype.baseType.setcontent(PLCOpenParser.CreateElement("BOOL", "dataType"))
setattr(cls, "appenddataTypeElement", appenddataTypeElement)
def insertdataTypeElement(self, index, dataType):
@@ -1072,9 +825,9 @@
def removedataTypeElement(self, name):
found = False
- for idx, element in enumerate(self.dataTypes.getdataType()):
+ for element in self.dataTypes.getdataType():
if element.getname() == name:
- self.dataTypes.removedataType(idx)
+ self.dataTypes.remove(element)
found = True
break
if not found:
@@ -1097,12 +850,12 @@
for element in self.pous.getpou():
if element.getname() == name:
raise ValueError, _("\"%s\" POU already exists !!!")%name
- new_pou = PLCOpenClasses["pous_pou"]()
+ new_pou = PLCOpenParser.CreateElement("pou", "pous")
+ self.pous.appendpou(new_pou)
new_pou.setname(name)
new_pou.setpouType(pou_type)
- new_pou.appendbody(PLCOpenClasses["body"]())
+ new_pou.appendbody(PLCOpenParser.CreateElement("body", "pou"))
new_pou.setbodyType(body_type)
- self.pous.appendpou(new_pou)
setattr(cls, "appendpouElement", appendpouElement)
def insertpouElement(self, index, pou):
@@ -1111,9 +864,9 @@
def removepouElement(self, name):
found = False
- for idx, element in enumerate(self.pous.getpou()):
+ for element in self.pous.getpou():
if element.getname() == name:
- self.pous.removepou(idx)
+ self.pous.remove(element)
found = True
break
if not found:
@@ -1133,7 +886,7 @@
def _updateBaseTypeElementName(self, old_name, new_name):
self.baseType.updateElementName(old_name, new_name)
-cls = PLCOpenClasses.get("dataTypes_dataType", None)
+cls = PLCOpenParser.GetElementClass("dataType", "dataTypes")
if cls:
setattr(cls, "updateElementName", _updateBaseTypeElementName)
@@ -1149,33 +902,45 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("dataType", None)
+cls = PLCOpenParser.GetElementClass("dataType")
if cls:
def updateElementName(self, old_name, new_name):
- if self.content["name"] in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]:
- self.content["value"].updateElementName(old_name, new_name)
- elif self.content["name"] == "struct":
- for element in self.content["value"].getvariable():
+ content_name = self.content.getLocalTag()
+ if content_name in ["derived", "array", "subrangeSigned", "subrangeUnsigned"]:
+ self.content.updateElementName(old_name, new_name)
+ elif content_name == "struct":
+ for element in self.content.getvariable():
element_type = element.type.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def Search(self, criteria, parent_infos=[]):
search_result = []
- if self.content["name"] in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]:
- search_result.extend(self.content["value"].Search(criteria, parent_infos))
- elif self.content["name"] == "struct":
- for i, element in enumerate(self.content["value"].getvariable()):
+ content_name = self.content.getLocalTag()
+ if content_name in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]:
+ search_result.extend(self.content.Search(criteria, parent_infos + ["base"]))
+ elif content_name == "struct":
+ for i, element in enumerate(self.content.getvariable()):
search_result.extend(element.Search(criteria, parent_infos + ["struct", i]))
else:
- basetype = self.content["name"]
- if basetype in ["string", "wstring"]:
- basetype = basetype.upper()
- search_result.extend(_Search([("base", basetype)], criteria, parent_infos))
+ if content_name in ["string", "wstring"]:
+ content_name = content_name.upper()
+ search_result.extend(_Search([("base", content_name)], criteria, parent_infos))
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("derivedTypes_array", None)
+cls = PLCOpenParser.GetElementClass("derived", "dataType")
+if cls:
+ def updateElementName(self, old_name, new_name):
+ if self.name == old_name:
+ self.name = new_name
+ setattr(cls, "updateElementName", updateElementName)
+
+ def Search(self, criteria, parent_infos=[]):
+ return [(tuple(parent_infos),) + result for result in TestTextElement(self.name, criteria)]
+ setattr(cls, "Search", Search)
+
+cls = PLCOpenParser.GetElementClass("array", "dataType")
if cls:
setattr(cls, "updateElementName", _updateBaseTypeElementName)
@@ -1195,68 +960,102 @@
criteria, parent_infos))
return search_result
-cls = PLCOpenClasses.get("derivedTypes_subrangeSigned", None)
+cls = PLCOpenParser.GetElementClass("subrangeSigned", "dataType")
if cls:
setattr(cls, "updateElementName", _updateBaseTypeElementName)
setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenClasses.get("derivedTypes_subrangeUnsigned", None)
+cls = PLCOpenParser.GetElementClass("subrangeUnsigned", "dataType")
if cls:
setattr(cls, "updateElementName", _updateBaseTypeElementName)
setattr(cls, "Search", _SearchInSubrange)
-cls = PLCOpenClasses.get("derivedTypes_enum", None)
+cls = PLCOpenParser.GetElementClass("enum", "dataType")
if cls:
def updateElementName(self, old_name, new_name):
pass
setattr(cls, "updateElementName", updateElementName)
+ enumerated_datatype_values_xpath = PLCOpen_XPath("ppx:values/ppx:value")
def Search(self, criteria, parent_infos=[]):
search_result = []
- for i, value in enumerate(self.values.getvalue()):
+ for i, value in enumerate(enumerated_datatype_values_xpath(self)):
for result in TestTextElement(value.getname(), criteria):
search_result.append((tuple(parent_infos + ["value", i]),) + result)
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("pous_pou", None)
-if cls:
+def _getvariableTypeinfos(variable_type):
+ type_content = variable_type.getcontent()
+ type_content_type = type_content.getLocalTag()
+ if type_content_type == "derived":
+ return type_content.getname()
+ return type_content_type.upper()
+
+cls = PLCOpenParser.GetElementClass("pou", "pous")
+if cls:
+
+ block_inputs_xpath = PLCOpen_XPath(
+ "ppx:interface/*[self::ppx:inputVars or self::ppx:inOutVars]/ppx:variable")
+ block_outputs_xpath = PLCOpen_XPath(
+ "ppx:interface/*[self::ppx:outputVars or self::ppx:inOutVars]/ppx:variable")
+ def getblockInfos(self):
+ block_infos = {
+ "name" : self.getname(),
+ "type" : self.getpouType(),
+ "extensible" : False,
+ "inputs" : [],
+ "outputs" : [],
+ "comment" : self.getdescription(),
+ "generate" : generate_block,
+ "initialise" : initialise_block}
+ if self.interface is not None:
+ return_type = self.interface.getreturnType()
+ if return_type is not None:
+ block_infos["outputs"].append(
+ ("OUT", _getvariableTypeinfos(return_type), "none"))
+ block_infos["inputs"].extend(
+ [(var.getname(), _getvariableTypeinfos(var.type), "none")
+ for var in block_inputs_xpath(self)])
+ block_infos["outputs"].extend(
+ [(var.getname(), _getvariableTypeinfos(var.type), "none")
+ for var in block_outputs_xpath(self)])
+
+ block_infos["usage"] = ("\n (%s) => (%s)" %
+ (", ".join(["%s:%s" % (input[1], input[0])
+ for input in block_infos["inputs"]]),
+ ", ".join(["%s:%s" % (output[1], output[0])
+ for output in block_infos["outputs"]])))
+ return block_infos
+ setattr(cls, "getblockInfos", getblockInfos)
def setdescription(self, description):
doc = self.getdocumentation()
if doc is None:
- doc = PLCOpenClasses["formattedText"]()
+ doc = PLCOpenParser.CreateElement("documentation", "pou")
self.setdocumentation(doc)
- doc.settext(description)
+ doc.setanyText(description)
setattr(cls, "setdescription", setdescription)
def getdescription(self):
doc = self.getdocumentation()
if doc is not None:
- return doc.gettext()
+ return doc.getanyText()
return ""
setattr(cls, "getdescription", getdescription)
- def setbodyType(self, type):
+ def setbodyType(self, body_type):
if len(self.body) > 0:
- if type == "IL":
- self.body[0].setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
- elif type == "ST":
- self.body[0].setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
- elif type == "LD":
- self.body[0].setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
- elif type == "FBD":
- self.body[0].setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
- elif type == "SFC":
- self.body[0].setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
+ if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:
+ self.body[0].setcontent(PLCOpenParser.CreateElement(body_type, "body"))
else:
raise ValueError, "%s isn't a valid body type!"%type
setattr(cls, "setbodyType", setbodyType)
def getbodyType(self):
if len(self.body) > 0:
- return self.body[0].getcontent()["name"]
+ return self.body[0].getcontent().getLocalTag()
setattr(cls, "getbodyType", getbodyType)
def resetexecutionOrder(self):
@@ -1274,9 +1073,9 @@
self.body[0].setelementExecutionOrder(instance, new_executionOrder)
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
- def addinstance(self, name, instance):
+ def addinstance(self, instance):
if len(self.body) > 0:
- self.body[0].appendcontentInstance(name, instance)
+ self.body[0].appendcontentInstance(instance)
setattr(cls, "addinstance", addinstance)
def getinstances(self):
@@ -1326,88 +1125,87 @@
for name, value in VarTypes.items():
reverse_types[value] = name
for varlist in self.interface.getcontent():
- vars.append((reverse_types[varlist["name"]], varlist["value"]))
+ vars.append((reverse_types[varlist.getLocalTag()], varlist))
return vars
setattr(cls, "getvars", getvars)
def setvars(self, vars):
if self.interface is None:
- self.interface = PLCOpenClasses["pou_interface"]()
- self.interface.setcontent([])
- for vartype, varlist in vars:
- self.interface.appendcontent({"name" : VarTypes[vartype], "value" : varlist})
+ self.interface = PLCOpenParser.CreateElement("interface", "pou")
+ self.interface.setcontent(vars)
setattr(cls, "setvars", setvars)
- def addpouLocalVar(self, type, name, location="", description=""):
- self.addpouVar(type, name, location=location, description=description)
+ def addpouLocalVar(self, var_type, name, location="", description=""):
+ self.addpouVar(var_type, name, location=location, description=description)
setattr(cls, "addpouLocalVar", addpouLocalVar)
- def addpouExternalVar(self, type, name):
+ def addpouExternalVar(self, var_type, name):
self.addpouVar(type, name, "externalVars")
setattr(cls, "addpouExternalVar", addpouExternalVar)
- def addpouVar(self, type, name, var_class="localVars", location="", description=""):
+ def addpouVar(self, var_type, name, var_class="localVars", location="", description=""):
if self.interface is None:
- self.interface = PLCOpenClasses["pou_interface"]()
+ self.interface = PLCOpenParser.CreateElement("interface", "pou")
content = self.interface.getcontent()
- if len(content) == 0 or content[-1]["name"] != var_class:
- content.append({"name" : var_class, "value" : PLCOpenClasses["interface_%s" % var_class]()})
+ if len(content) == 0:
+ varlist = PLCOpenParser.CreateElement(var_class, "interface")
+ self.interface.setcontent([varlist])
+ elif content[-1] != var_class:
+ varlist = PLCOpenParser.CreateElement(var_class, "interface")
+ content[-1].addnext(varlist)
else:
- varlist = content[-1]["value"]
+ varlist = content[-1]
variables = varlist.getvariable()
if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress():
- content.append({"name" : var_class, "value" : PLCOpenClasses["interface_%s" % var_class]()})
- var = PLCOpenClasses["varListPlain_variable"]()
+ varlist = PLCOpenParser.CreateElement(var_class, "interface")
+ content[-1].addnext(varlist)
+ var = PLCOpenParser.CreateElement("variable", "varListPlain")
var.setname(name)
- var_type = PLCOpenClasses["dataType"]()
- if type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:
- if type == "STRING":
- var_type.setcontent({"name" : "string", "value" : PLCOpenClasses["elementaryTypes_string"]()})
- elif type == "WSTRING":
- var_type.setcontent({"name" : "wstring", "value" : PLCOpenClasses["elementaryTypes_wstring"]()})
- else:
- var_type.setcontent({"name" : type, "value" : None})
+ var_type_obj = PLCOpenParser.CreateElement("type", "variable")
+ if var_type in [x for x,y in TypeHierarchy_list if not x.startswith("ANY")]:
+ var_type_obj.setcontent(PLCOpenParser.CreateElement(
+ var_type.lower() if var_type in ["STRING", "WSTRING"]
+ else var_type, "dataType"))
else:
- derived_type = PLCOpenClasses["derivedTypes_derived"]()
- derived_type.setname(type)
- var_type.setcontent({"name" : "derived", "value" : derived_type})
- var.settype(var_type)
+ derived_type = PLCOpenParser.CreateElement("derived", "dataType")
+ derived_type.setname(var_type)
+ var_type_obj.setcontent(derived_type)
+ var.settype(var_type_obj)
if location != "":
var.setaddress(location)
if description != "":
- ft = PLCOpenClasses["formattedText"]()
- ft.settext(description)
+ ft = PLCOpenParser.CreateElement("documentation", "variable")
+ ft.setanyText(description)
var.setdocumentation(ft)
- content[-1]["value"].appendvariable(var)
+ varlist.appendvariable(var)
setattr(cls, "addpouVar", addpouVar)
def changepouVar(self, old_type, old_name, new_type, new_name):
if self.interface is not None:
content = self.interface.getcontent()
for varlist in content:
- variables = varlist["value"].getvariable()
+ variables = varlist.getvariable()
for var in variables:
if var.getname() == old_name:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived" and vartype_content["value"].getname() == old_type:
+ if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == old_type:
var.setname(new_name)
- vartype_content["value"].setname(new_type)
+ vartype_content.setname(new_type)
return
setattr(cls, "changepouVar", changepouVar)
- def removepouVar(self, type, name):
+ def removepouVar(self, var_type, name):
if self.interface is not None:
content = self.interface.getcontent()
for varlist in content:
- variables = varlist["value"].getvariable()
- for var in variables:
+ for var in varlist.getvariable():
if var.getname() == name:
vartype_content = var.gettype().getcontent()
- if vartype_content["name"] == "derived" and vartype_content["value"].getname() == type:
- variables.remove(var)
+ if vartype_content.getLocalTag() == "derived" and vartype_content.getname() == var_type:
+ varlist.remove(var)
break
- if len(varlist["value"].getvariable()) == 0:
+ if len(varlist.getvariable()) == 0:
content.remove(varlist)
break
setattr(cls, "removepouVar", removepouVar)
@@ -1415,7 +1213,7 @@
def hasblock(self, name=None, block_type=None):
if self.getbodyType() in ["FBD", "LD", "SFC"]:
for instance in self.getinstances():
- if (isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and
+ if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and
(name and instance.getinstanceName() == name or
block_type and instance.gettypeName() == block_type)):
return True
@@ -1434,22 +1232,22 @@
return False
setattr(cls, "hasblock", hasblock)
- def addtransition(self, name, type):
- if not self.transitions:
+ def addtransition(self, name, body_type):
+ if self.transitions is None:
self.addtransitions()
self.transitions.settransition([])
- transition = PLCOpenClasses["transitions_transition"]()
+ transition = PLCOpenParser.CreateElement("transition", "transitions")
+ self.transitions.appendtransition(transition)
transition.setname(name)
- transition.setbodyType(type)
- if type == "ST":
- transition.settext(":= ;")
- elif type == "IL":
- transition.settext("\tST\t%s"%name)
- self.transitions.appendtransition(transition)
+ transition.setbodyType(body_type)
+ if body_type == "ST":
+ transition.setanyText(":= ;")
+ elif body_type == "IL":
+ transition.setanyText("\tST\t%s"%name)
setattr(cls, "addtransition", addtransition)
def gettransition(self, name):
- if self.transitions:
+ if self.transitions is not None:
for transition in self.transitions.gettransition():
if transition.getname() == name:
return transition
@@ -1457,42 +1255,40 @@
setattr(cls, "gettransition", gettransition)
def gettransitionList(self):
- if self.transitions:
+ if self.transitions is not None:
return self.transitions.gettransition()
return []
setattr(cls, "gettransitionList", gettransitionList)
def removetransition(self, name):
- if self.transitions:
- transitions = self.transitions.gettransition()
- i = 0
+ if self.transitions is not None:
removed = False
- while i < len(transitions) and not removed:
- if transitions[i].getname() == name:
- if transitions[i].getbodyType() in ["FBD", "LD", "SFC"]:
- for instance in transitions[i].getinstances():
- if isinstance(instance, PLCOpenClasses["fbdObjects_block"]):
+ for transition in self.transitions.gettransition():
+ if transition.getname() == name:
+ if transition.getbodyType() in ["FBD", "LD", "SFC"]:
+ for instance in transition.getinstances():
+ if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
self.removepouVar(instance.gettypeName(),
instance.getinstanceName())
- transitions.pop(i)
+ self.transitions.remove(transition)
removed = True
- i += 1
+ break
if not removed:
raise ValueError, _("Transition with name %s doesn't exist!")%name
setattr(cls, "removetransition", removetransition)
- def addaction(self, name, type):
- if not self.actions:
+ def addaction(self, name, body_type):
+ if self.actions is None:
self.addactions()
self.actions.setaction([])
- action = PLCOpenClasses["actions_action"]()
+ action = PLCOpenParser.CreateElement("action", "actions")
+ self.actions.appendaction(action)
action.setname(name)
- action.setbodyType(type)
- self.actions.appendaction(action)
+ action.setbodyType(body_type)
setattr(cls, "addaction", addaction)
def getaction(self, name):
- if self.actions:
+ if self.actions is not None:
for action in self.actions.getaction():
if action.getname() == name:
return action
@@ -1506,28 +1302,26 @@
setattr(cls, "getactionList", getactionList)
def removeaction(self, name):
- if self.actions:
- actions = self.actions.getaction()
- i = 0
+ if self.actions is not None:
removed = False
- while i < len(actions) and not removed:
- if actions[i].getname() == name:
- if actions[i].getbodyType() in ["FBD", "LD", "SFC"]:
- for instance in actions[i].getinstances():
- if isinstance(instance, PLCOpenClasses["fbdObjects_block"]):
+ for action in self.actions.getaction():
+ if action.getname() == name:
+ if action.getbodyType() in ["FBD", "LD", "SFC"]:
+ for instance in action.getinstances():
+ if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
self.removepouVar(instance.gettypeName(),
instance.getinstanceName())
- actions.pop(i)
+ self.actions.remove(action)
removed = True
- i += 1
+ break
if not removed:
raise ValueError, _("Action with name %s doesn't exist!")%name
setattr(cls, "removeaction", removeaction)
def updateElementName(self, old_name, new_name):
- if self.interface:
+ if self.interface is not None:
for content in self.interface.getcontent():
- for var in content["value"].getvariable():
+ for var in content.getvariable():
var_address = var.getaddress()
if var_address is not None:
if var_address == old_name:
@@ -1535,9 +1329,9 @@
if var.getname() == old_name:
var.setname(new_name)
var_type_content = var.gettype().getcontent()
- if var_type_content["name"] == "derived":
- if var_type_content["value"].getname() == old_name:
- var_type_content["value"].setname(new_name)
+ if var_type_content.getLocalTag() == "derived":
+ if var_type_content.getname() == old_name:
+ var_type_content.setname(new_name)
self.body[0].updateElementName(old_name, new_name)
for action in self.getactionList():
action.updateElementName(old_name, new_name)
@@ -1546,9 +1340,9 @@
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.interface:
+ if self.interface is not None:
for content in self.interface.getcontent():
- for var in content["value"].getvariable():
+ for var in content.getvariable():
var_address = var.getaddress()
if var_address is not None:
var.setaddress(update_address(var_address, address_model, new_leading))
@@ -1560,24 +1354,22 @@
setattr(cls, "updateElementAddress", updateElementAddress)
def removeVariableByAddress(self, address):
- if self.interface:
+ if self.interface is not None:
for content in self.interface.getcontent():
- variables = content["value"].getvariable()
- for i in xrange(len(variables)-1, -1, -1):
- if variables[i].getaddress() == address:
- variables.pop(i)
+ for variable in content.getvariable():
+ if variable.getaddress() == address:
+ content.remove(variable)
setattr(cls, "removeVariableByAddress", removeVariableByAddress)
def removeVariableByFilter(self, address_model):
- if self.interface:
+ if self.interface is not None:
for content in self.interface.getcontent():
- variables = content["value"].getvariable()
- for i in xrange(len(variables)-1, -1, -1):
- var_address = variables[i].getaddress()
+ for variable in content.getvariable():
+ var_address = variable.getaddress()
if var_address is not None:
result = address_model.match(var_address)
if result is not None:
- variables.pop(i)
+ content.remove(variable)
setattr(cls, "removeVariableByFilter", removeVariableByFilter)
def Search(self, criteria, parent_infos=[]):
@@ -1589,11 +1381,11 @@
if self.interface is not None:
var_number = 0
for content in self.interface.getcontent():
- variable_type = searchResultVarTypes.get(content["value"], "var_local")
- variables = content["value"].getvariable()
- for modifier, has_modifier in [("constant", content["value"].getconstant()),
- ("retain", content["value"].getretain()),
- ("non_retain", content["value"].getnonretain())]:
+ variable_type = searchResultVarTypes.get(content, "var_local")
+ variables = content.getvariable()
+ for modifier, has_modifier in [("constant", content.getconstant()),
+ ("retain", content.getretain()),
+ ("non_retain", content.getnonretain())]:
if has_modifier:
for result in TestTextElement(modifier, criteria):
search_result.append((tuple(parent_infos + [variable_type, (var_number, var_number + len(variables)), modifier]),) + result)
@@ -1610,22 +1402,14 @@
return search_result
setattr(cls, "Search", Search)
-def setbodyType(self, type):
- if type == "IL":
- self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
- elif type == "ST":
- self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
- elif type == "LD":
- self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
- elif type == "FBD":
- self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
- elif type == "SFC":
- self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
+def setbodyType(self, body_type):
+ if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:
+ self.body.setcontent(PLCOpenParser.CreateElement(body_type, "body"))
else:
raise ValueError, "%s isn't a valid body type!"%type
def getbodyType(self):
- return self.body.getcontent()["name"]
+ return self.body.getcontent().getLocalTag()
def resetexecutionOrder(self):
self.body.resetexecutionOrder()
@@ -1636,8 +1420,8 @@
def setelementExecutionOrder(self, instance, new_executionOrder):
self.body.setelementExecutionOrder(instance, new_executionOrder)
-def addinstance(self, name, instance):
- self.body.appendcontentInstance(name, instance)
+def addinstance(self, instance):
+ self.body.appendcontentInstance(instance)
def getinstances(self):
return self.body.getcontentInstances()
@@ -1663,7 +1447,7 @@
def hasblock(self, name=None, block_type=None):
if self.getbodyType() in ["FBD", "LD", "SFC"]:
for instance in self.getinstances():
- if (isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and
+ if (isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and
(name and instance.getinstanceName() == name or
block_type and instance.gettypeName() == block_type)):
return True
@@ -1678,7 +1462,7 @@
self.body.updateElementAddress(address_model, new_leading)
-cls = PLCOpenClasses.get("transitions_transition", None)
+cls = PLCOpenParser.GetElementClass("transition", "transitions")
if cls:
setattr(cls, "setbodyType", setbodyType)
setattr(cls, "getbodyType", getbodyType)
@@ -1706,7 +1490,7 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("actions_action", None)
+cls = PLCOpenParser.GetElementClass("action", "actions")
if cls:
setattr(cls, "setbodyType", setbodyType)
setattr(cls, "getbodyType", getbodyType)
@@ -1734,27 +1518,9 @@
return search_result
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("body", None)
+cls = PLCOpenParser.GetElementClass("body")
if cls:
cls.currentExecutionOrderId = 0
- cls.instances_dict = {}
-
- setattr(cls, "_init_", getattr(cls, "__init__"))
-
- def __init__(self, *args, **kwargs):
- self._init_(*args, **kwargs)
- self.instances_dict = {}
- setattr(cls, "__init__", __init__)
-
- setattr(cls, "_loadXMLTree", getattr(cls, "loadXMLTree"))
-
- def loadXMLTree(self, *args, **kwargs):
- self._loadXMLTree(*args, **kwargs)
- if self.content["name"] in ["LD","FBD","SFC"]:
- self.instances_dict = dict(
- [(element["value"].getlocalId(), element)
- for element in self.content["value"].getcontent()])
- setattr(cls, "loadXMLTree", loadXMLTree)
def resetcurrentExecutionOrderId(self):
object.__setattr__(self, "currentExecutionOrderId", 0)
@@ -1766,44 +1532,44 @@
setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId)
def resetexecutionOrder(self):
- if self.content["name"] == "FBD":
- for element in self.content["value"].getcontent():
- if not isinstance(element["value"], (PLCOpenClasses.get("commonObjects_comment", None),
- PLCOpenClasses.get("commonObjects_connector", None),
- PLCOpenClasses.get("commonObjects_continuation", None))):
- element["value"].setexecutionOrderId(0)
+ if self.content.getLocalTag() == "FBD":
+ for element in self.content.getcontent():
+ if not isinstance(element, (PLCOpenParser.GetElementClass("comment", "commonObjects"),
+ PLCOpenParser.GetElementClass("connector", "commonObjects"),
+ PLCOpenParser.GetElementClass("continuation", "commonObjects"))):
+ element.setexecutionOrderId(0)
else:
raise TypeError, _("Can only generate execution order on FBD networks!")
setattr(cls, "resetexecutionOrder", resetexecutionOrder)
def compileexecutionOrder(self):
- if self.content["name"] == "FBD":
+ if self.content.getLocalTag() == "FBD":
self.resetexecutionOrder()
self.resetcurrentExecutionOrderId()
- for element in self.content["value"].getcontent():
- if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_outVariable", None)) and element["value"].getexecutionOrderId() == 0:
- connections = element["value"].connectionPointIn.getconnections()
+ for element in self.content.getcontent():
+ if isinstance(element, PLCOpenParser.GetElementClass("outVariable", "fbdObjects")) and element.getexecutionOrderId() == 0:
+ connections = element.connectionPointIn.getconnections()
if connections and len(connections) == 1:
self.compileelementExecutionOrder(connections[0])
- element["value"].setexecutionOrderId(self.getnewExecutionOrderId())
+ element.setexecutionOrderId(self.getnewExecutionOrderId())
else:
raise TypeError, _("Can only generate execution order on FBD networks!")
setattr(cls, "compileexecutionOrder", compileexecutionOrder)
def compileelementExecutionOrder(self, link):
- if self.content["name"] == "FBD":
+ if self.content.getLocalTag() == "FBD":
localid = link.getrefLocalId()
instance = self.getcontentInstance(localid)
- if isinstance(instance, PLCOpenClasses.get("fbdObjects_block", None)) and instance.getexecutionOrderId() == 0:
+ if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")) and instance.getexecutionOrderId() == 0:
for variable in instance.inputVariables.getvariable():
connections = variable.connectionPointIn.getconnections()
if connections and len(connections) == 1:
self.compileelementExecutionOrder(connections[0])
instance.setexecutionOrderId(self.getnewExecutionOrderId())
- elif isinstance(instance, PLCOpenClasses.get("commonObjects_continuation", None)) and instance.getexecutionOrderId() == 0:
+ elif isinstance(instance, PLCOpenParser.GetElementClass("continuation", "commonObjects")) and instance.getexecutionOrderId() == 0:
name = instance.getname()
for tmp_instance in self.getcontentInstances():
- if isinstance(tmp_instance, PLCOpenClasses.get("commonObjects_connector", None)) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:
+ if isinstance(tmp_instance, PLCOpenParser.GetElementClass("connector", "commonObjects")) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:
connections = tmp_instance.connectionPointIn.getconnections()
if connections and len(connections) == 1:
self.compileelementExecutionOrder(connections[0])
@@ -1812,124 +1578,125 @@
setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder)
def setelementExecutionOrder(self, instance, new_executionOrder):
- if self.content["name"] == "FBD":
+ if self.content.getLocalTag() == "FBD":
old_executionOrder = instance.getexecutionOrderId()
if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0:
- for element in self.content["value"].getcontent():
- if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("commonObjects_comment", None)):
- element_executionOrder = element["value"].getexecutionOrderId()
+ for element in self.content.getcontent():
+ if element != instance and not isinstance(element, PLCOpenParser.GetElementClass("comment", "commonObjects")):
+ element_executionOrder = element.getexecutionOrderId()
if old_executionOrder <= element_executionOrder <= new_executionOrder:
- element["value"].setexecutionOrderId(element_executionOrder - 1)
+ element.setexecutionOrderId(element_executionOrder - 1)
if new_executionOrder <= element_executionOrder <= old_executionOrder:
- element["value"].setexecutionOrderId(element_executionOrder + 1)
+ element.setexecutionOrderId(element_executionOrder + 1)
instance.setexecutionOrderId(new_executionOrder)
else:
raise TypeError, _("Can only generate execution order on FBD networks!")
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
- def appendcontentInstance(self, name, instance):
- if self.content["name"] in ["LD","FBD","SFC"]:
- element = {"name" : name, "value" : instance}
- self.content["value"].appendcontent(element)
- self.instances_dict[instance.getlocalId()] = element
+ def appendcontentInstance(self, instance):
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ self.content.appendcontent(instance)
else:
- raise TypeError, _("%s body don't have instances!")%self.content["name"]
+ raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
setattr(cls, "appendcontentInstance", appendcontentInstance)
def getcontentInstances(self):
- if self.content["name"] in ["LD","FBD","SFC"]:
- instances = []
- for element in self.content["value"].getcontent():
- instances.append(element["value"])
- return instances
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ return self.content.getcontent()
else:
- raise TypeError, _("%s body don't have instances!")%self.content["name"]
+ raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
setattr(cls, "getcontentInstances", getcontentInstances)
-
- def getcontentInstance(self, id):
- if self.content["name"] in ["LD","FBD","SFC"]:
- instance = self.instances_dict.get(id, None)
- if instance is not None:
- return instance["value"]
+
+ instance_by_id_xpath = PLCOpen_XPath("*[@localId=$localId]")
+ instance_by_name_xpath = PLCOpen_XPath("ppx:block[@instanceName=$name]")
+ def getcontentInstance(self, local_id):
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ instance = instance_by_id_xpath(self.content, localId=local_id)
+ if len(instance) > 0:
+ return instance[0]
return None
else:
- raise TypeError, _("%s body don't have instances!")%self.content["name"]
+ raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
setattr(cls, "getcontentInstance", getcontentInstance)
def getcontentRandomInstance(self, exclude):
- if self.content["name"] in ["LD","FBD","SFC"]:
- ids = self.instances_dict.viewkeys() - exclude
- if len(ids) > 0:
- return self.instances_dict[ids.pop()]["value"]
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ instance = self.content.xpath("*%s[position()=1]" %
+ ("[not(%s)]" % " or ".join(
+ map(lambda x: "@localId=%d" % x, exclude))
+ if len(exclude) > 0 else ""))
+ if len(instance) > 0:
+ return instance[0]
return None
else:
- raise TypeError, _("%s body don't have instances!")%self.content["name"]
+ raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
setattr(cls, "getcontentRandomInstance", getcontentRandomInstance)
def getcontentInstanceByName(self, name):
- if self.content["name"] in ["LD","FBD","SFC"]:
- for element in self.content["value"].getcontent():
- if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_block", None)) and element["value"].getinstanceName() == name:
- return element["value"]
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ instance = instance_by_name_xpath(self.content)
+ if len(instance) > 0:
+ return instance[0]
+ return None
else:
- raise TypeError, _("%s body don't have instances!")%self.content["name"]
+ raise TypeError, _("%s body don't have instances!")%self.content.getLocalTag()
setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)
- def removecontentInstance(self, id):
- if self.content["name"] in ["LD","FBD","SFC"]:
- element = self.instances_dict.pop(id, None)
- if element is not None:
- self.content["value"].getcontent().remove(element)
+ def removecontentInstance(self, local_id):
+ if self.content.getLocalTag() in ["LD","FBD","SFC"]:
+ instance = instance_by_id_xpath(self.content)
+ if len(instance) > 0:
+ self.content.remove(instance[0])
else:
raise ValueError, _("Instance with id %d doesn't exist!")%id
else:
- raise TypeError, "%s body don't have instances!"%self.content["name"]
+ raise TypeError, "%s body don't have instances!"%self.content.getLocalTag()
setattr(cls, "removecontentInstance", removecontentInstance)
def settext(self, text):
- if self.content["name"] in ["IL","ST"]:
- self.content["value"].settext(text)
+ if self.content.getLocalTag() in ["IL","ST"]:
+ self.content.setanyText(text)
else:
- raise TypeError, _("%s body don't have text!")%self.content["name"]
+ raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
setattr(cls, "settext", settext)
def gettext(self):
- if self.content["name"] in ["IL","ST"]:
- return self.content["value"].gettext()
+ if self.content.getLocalTag() in ["IL","ST"]:
+ return self.content.getanyText()
else:
- raise TypeError, _("%s body don't have text!")%self.content["name"]
+ raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
setattr(cls, "gettext", gettext)
def hasblock(self, block_type):
- if self.content["name"] in ["IL","ST"]:
- return self.content["value"].hasblock(block_type)
+ if self.content.getLocalTag() in ["IL","ST"]:
+ return self.content.hasblock(block_type)
else:
- raise TypeError, _("%s body don't have text!")%self.content["name"]
+ raise TypeError, _("%s body don't have text!")%self.content.getLocalTag()
setattr(cls, "hasblock", hasblock)
def updateElementName(self, old_name, new_name):
- if self.content["name"] in ["IL", "ST"]:
- self.content["value"].updateElementName(old_name, new_name)
+ if self.content.getLocalTag() in ["IL", "ST"]:
+ self.content.updateElementName(old_name, new_name)
else:
- for element in self.content["value"].getcontent():
- element["value"].updateElementName(old_name, new_name)
+ for element in self.content.getcontent():
+ element.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.content["name"] in ["IL", "ST"]:
- self.content["value"].updateElementAddress(address_model, new_leading)
+ if self.content.getLocalTag() in ["IL", "ST"]:
+ self.content.updateElementAddress(address_model, new_leading)
else:
- for element in self.content["value"].getcontent():
- element["value"].updateElementAddress(address_model, new_leading)
+ for element in self.content.getcontent():
+ element.updateElementAddress(address_model, new_leading)
setattr(cls, "updateElementAddress", updateElementAddress)
def Search(self, criteria, parent_infos=[]):
- if self.content["name"] in ["IL", "ST"]:
- search_result = self.content["value"].Search(criteria, parent_infos + ["body", 0])
+ if self.content.getLocalTag() in ["IL", "ST"]:
+ search_result = self.content.Search(criteria, parent_infos + ["body", 0])
else:
search_result = []
- for element in self.content["value"].getcontent():
- search_result.extend(element["value"].Search(criteria, parent_infos))
+ for element in self.content.getcontent():
+ search_result.extend(element.Search(criteria, parent_infos))
return search_result
setattr(cls, "Search", Search)
@@ -1972,15 +1739,11 @@
def _filterConnections(connectionPointIn, localId, connections):
in_connections = connectionPointIn.getconnections()
if in_connections is not None:
- to_delete = []
- for i, connection in enumerate(in_connections):
+ for connection in in_connections:
connected = connection.getrefLocalId()
if not connections.has_key((localId, connected)) and \
not connections.has_key((connected, localId)):
- to_delete.append(i)
- to_delete.reverse()
- for i in to_delete:
- connectionPointIn.removeconnection(i)
+ connectionPointIn.remove(connection)
def _filterConnectionsSingle(self, connections):
if self.connectionPointIn is not None:
@@ -1991,8 +1754,8 @@
_filterConnections(connectionPointIn, self.localId, connections)
def _getconnectionsdefinition(instance, connections_end):
- id = instance.getlocalId()
- return dict([((id, end), True) for end in connections_end])
+ local_id = instance.getlocalId()
+ return dict([((local_id, end), True) for end in connections_end])
def _updateConnectionsId(connectionPointIn, translation):
connections_end = []
@@ -2063,9 +1826,8 @@
"multiple": _updateConnectionsIdMultiple},
}
-def _initElementClass(name, classname, connectionPointInType="none"):
- ElementNameToClass[name] = classname
- cls = PLCOpenClasses.get(classname, None)
+def _initElementClass(name, parent, connectionPointInType="none"):
+ cls = PLCOpenParser.GetElementClass(name, parent)
if cls:
setattr(cls, "getx", getx)
setattr(cls, "gety", gety)
@@ -2133,7 +1895,7 @@
infos = _getelementinfos(self)
infos["type"] = type
specific_values = infos["specific_values"]
- specific_values["name"] = self.getexpression()
+ specific_values["name"] = self.getexpression().text
_getexecutionOrder(self, specific_values)
if input and output:
infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True, "input"))
@@ -2146,7 +1908,7 @@
return getvariableinfos
def _getconnectorinfosFunction(type):
- def getvariableinfos(self):
+ def getconnectorinfos(self):
infos = _getelementinfos(self)
infos["type"] = type
infos["specific_values"]["name"] = self.getname()
@@ -2155,7 +1917,7 @@
elif type == "continuation":
infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))
return infos
- return getvariableinfos
+ return getconnectorinfos
def _getpowerrailinfosFunction(type):
def getpowerrailinfos(self):
@@ -2172,16 +1934,16 @@
return infos
return getpowerrailinfos
-def _getldelementinfosFunction(type):
+def _getldelementinfosFunction(ld_element_type):
def getldelementinfos(self):
infos = _getelementinfos(self)
- infos["type"] = type
+ infos["type"] = ld_element_type
specific_values = infos["specific_values"]
- specific_values["name"] = self.getvariable()
+ specific_values["name"] = self.getvariable().text
_getexecutionOrder(self, specific_values)
specific_values["negated"] = self.getnegated()
specific_values["edge"] = self.getedge()
- if type == "coil":
+ if ld_element_type == "coil":
specific_values["storage"] = self.getstorage()
infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True))
infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))
@@ -2210,7 +1972,7 @@
return infos
return getdivergenceinfos
-cls = _initElementClass("comment", "commonObjects_comment")
+cls = _initElementClass("comment", "commonObjects")
if cls:
def getinfos(self):
infos = _getelementinfos(self)
@@ -2220,11 +1982,11 @@
setattr(cls, "getinfos", getinfos)
def setcontentText(self, text):
- self.content.settext(text)
+ self.content.setanyText(text)
setattr(cls, "setcontentText", setcontentText)
def getcontentText(self):
- return self.content.gettext()
+ return self.content.getanyText()
setattr(cls, "getcontentText", getcontentText)
def updateElementName(self, old_name, new_name):
@@ -2239,7 +2001,7 @@
return self.content.Search(criteria, parent_infos + ["comment", self.getlocalId(), "content"])
setattr(cls, "Search", Search)
-cls = _initElementClass("block", "fbdObjects_block")
+cls = _initElementClass("block", "fbdObjects")
if cls:
def getBoundingBox(self):
bbox = _getBoundingBox(self)
@@ -2298,49 +2060,41 @@
return search_result
setattr(cls, "Search", Search)
-cls = _initElementClass("leftPowerRail", "ldObjects_leftPowerRail")
+cls = _initElementClass("leftPowerRail", "ldObjects")
if cls:
setattr(cls, "getinfos", _getpowerrailinfosFunction("leftPowerRail"))
-cls = _initElementClass("rightPowerRail", "ldObjects_rightPowerRail", "multiple")
+cls = _initElementClass("rightPowerRail", "ldObjects", "multiple")
if cls:
setattr(cls, "getinfos", _getpowerrailinfosFunction("rightPowerRail"))
-cls = _initElementClass("contact", "ldObjects_contact", "single")
+def _UpdateLDElementName(self, old_name, new_name):
+ if self.variable.text == old_name:
+ self.variable.text = new_name
+
+def _UpdateLDElementAddress(self, address_model, new_leading):
+ self.variable.text = update_address(self.variable.text, address_model, new_leading)
+
+def _getSearchInLDElement(ld_element_type):
+ def SearchInLDElement(self, criteria, parent_infos=[]):
+ return _Search([("reference", self.variable.text)], criteria, parent_infos + [ld_element_type, self.getlocalId()])
+ return SearchInLDElement
+
+cls = _initElementClass("contact", "ldObjects", "single")
if cls:
setattr(cls, "getinfos", _getldelementinfosFunction("contact"))
-
- def updateElementName(self, old_name, new_name):
- if self.variable == old_name:
- self.variable = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.variable = update_address(self.variable, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
- def Search(self, criteria, parent_infos=[]):
- return _Search([("reference", self.getvariable())], criteria, parent_infos + ["contact", self.getlocalId()])
- setattr(cls, "Search", Search)
-
-cls = _initElementClass("coil", "ldObjects_coil", "single")
+ setattr(cls, "updateElementName", _UpdateLDElementName)
+ setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
+ setattr(cls, "Search", _getSearchInLDElement("contact"))
+
+cls = _initElementClass("coil", "ldObjects", "single")
if cls:
setattr(cls, "getinfos", _getldelementinfosFunction("coil"))
-
- def updateElementName(self, old_name, new_name):
- if self.variable == old_name:
- self.variable = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.variable = update_address(self.variable, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
- def Search(self, criteria, parent_infos=[]):
- return _Search([("reference", self.getvariable())], criteria, parent_infos + ["coil", self.getlocalId()])
- setattr(cls, "Search", Search)
-
-cls = _initElementClass("step", "sfcObjects_step", "single")
+ setattr(cls, "updateElementName", _UpdateLDElementName)
+ setattr(cls, "updateElementAddress", _UpdateLDElementAddress)
+ setattr(cls, "Search", _getSearchInLDElement("coil"))
+
+cls = _initElementClass("step", "sfcObjects", "single")
if cls:
def getinfos(self):
infos = _getelementinfos(self)
@@ -2348,11 +2102,11 @@
specific_values = infos["specific_values"]
specific_values["name"] = self.getname()
specific_values["initial"] = self.getinitialStep()
- if self.connectionPointIn:
+ if self.connectionPointIn is not None:
infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True))
- if self.connectionPointOut:
+ if self.connectionPointOut is not None:
infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))
- if self.connectionPointOutAction:
+ if self.connectionPointOutAction is not None:
specific_values["action"] = _getconnectioninfos(self, self.connectionPointOutAction)
return infos
setattr(cls, "getinfos", getinfos)
@@ -2361,7 +2115,7 @@
return _Search([("name", self.getname())], criteria, parent_infos + ["step", self.getlocalId()])
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("transition_condition", None)
+cls = PLCOpenParser.GetElementClass("condition", "transition")
if cls:
def compatibility(self, tree):
connections = []
@@ -2378,7 +2132,7 @@
tree.childNodes = [node]
setattr(cls, "compatibility", compatibility)
-cls = _initElementClass("transition", "sfcObjects_transition")
+cls = _initElementClass("transition", "sfcObjects")
if cls:
def getinfos(self):
infos = _getelementinfos(self)
@@ -2399,49 +2153,48 @@
return infos
setattr(cls, "getinfos", getinfos)
- def setconditionContent(self, type, value):
- if not self.condition:
+ def setconditionContent(self, condition_type, value):
+ if self.condition is None:
self.addcondition()
- if type == "reference":
- condition = PLCOpenClasses["condition_reference"]()
+ if condition_type == "connection":
+ condition = PLCOpenParser.CreateElement("connectionPointIn", "condition")
+ else:
+ condition = PLCOpenParser.CreateElement(condition_type, "condition")
+ self.condition.setcontent(condition)
+ if condition_type == "reference":
condition.setname(value)
- elif type == "inline":
- condition = PLCOpenClasses["condition_inline"]()
- condition.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
+ elif condition_type == "inline":
+ condition.setcontent(PLCOpenParser.CreateElement("ST", "inline"))
condition.settext(value)
- elif type == "connection":
- type = "connectionPointIn"
- condition = PLCOpenClasses["connectionPointIn"]()
- self.condition.setcontent({"name" : type, "value" : condition})
setattr(cls, "setconditionContent", setconditionContent)
def getconditionContent(self):
- if self.condition:
+ if self.condition is not None:
content = self.condition.getcontent()
- values = {"type" : content["name"]}
+ values = {"type" : content.getLocalTag()}
if values["type"] == "reference":
- values["value"] = content["value"].getname()
+ values["value"] = content.getname()
elif values["type"] == "inline":
- values["value"] = content["value"].gettext()
+ values["value"] = content.gettext()
elif values["type"] == "connectionPointIn":
values["type"] = "connection"
- values["value"] = content["value"]
+ values["value"] = content
return values
return ""
setattr(cls, "getconditionContent", getconditionContent)
def getconditionConnection(self):
- if self.condition:
+ if self.condition is not None:
content = self.condition.getcontent()
- if content["name"] == "connectionPointIn":
- return content["value"]
+ if content.getLocalTag() == "connectionPointIn":
+ return content
return None
setattr(cls, "getconditionConnection", getconditionConnection)
def getBoundingBox(self):
bbox = _getBoundingBoxSingle(self)
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
bbox.union(_getConnectionsBoundingBox(condition_connection))
return bbox
setattr(cls, "getBoundingBox", getBoundingBox)
@@ -2449,14 +2202,14 @@
def translate(self, dx, dy):
_translateSingle(self, dx, dy)
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
_translateConnections(condition_connection, dx, dy)
setattr(cls, "translate", translate)
def filterConnections(self, connections):
_filterConnectionsSingle(self, connections)
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
_filterConnections(condition_connection, self.localId, connections)
setattr(cls, "filterConnections", filterConnections)
@@ -2465,33 +2218,35 @@
if self.connectionPointIn is not None:
connections_end = _updateConnectionsId(self.connectionPointIn, translation)
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
connections_end.extend(_updateConnectionsId(condition_connection, translation))
return _getconnectionsdefinition(self, connections_end)
setattr(cls, "updateConnectionsId", updateConnectionsId)
def updateElementName(self, old_name, new_name):
- if self.condition:
+ if self.condition is not None:
content = self.condition.getcontent()
- if content["name"] == "reference":
- if content["value"].getname() == old_name:
- content["value"].setname(new_name)
- elif content["name"] == "inline":
- content["value"].updateElementName(old_name, new_name)
+ content_name = content.getLocalTag()
+ if content_name == "reference":
+ if content.getname() == old_name:
+ content.setname(new_name)
+ elif content_name == "inline":
+ content.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.condition:
+ if self.condition is not None:
content = self.condition.getcontent()
- if content["name"] == "reference":
- content["value"].setname(update_address(content["value"].getname(), address_model, new_leading))
- elif content["name"] == "inline":
- content["value"].updateElementAddress(address_model, new_leading)
+ content_name = content.getLocalTag()
+ if content_name == "reference":
+ content.setname(update_address(content.getname(), address_model, new_leading))
+ elif content_name == "inline":
+ content.updateElementAddress(address_model, new_leading)
setattr(cls, "updateElementAddress", updateElementAddress)
def getconnections(self):
condition_connection = self.getconditionConnection()
- if condition_connection:
+ if condition_connection is not None:
return condition_connection.getconnections()
return None
setattr(cls, "getconnections", getconnections)
@@ -2500,30 +2255,31 @@
parent_infos = parent_infos + ["transition", self.getlocalId()]
search_result = []
content = self.condition.getcontent()
- if content["name"] == "reference":
- search_result.extend(_Search([("reference", content["value"].getname())], criteria, parent_infos))
- elif content["name"] == "inline":
- search_result.extend(content["value"].Search(criteria, parent_infos + ["inline"]))
+ content_name = content.getLocalTag()
+ if content_name == "reference":
+ search_result.extend(_Search([("reference", content.getname())], criteria, parent_infos))
+ elif content_name == "inline":
+ search_result.extend(content.Search(criteria, parent_infos + ["inline"]))
return search_result
setattr(cls, "Search", Search)
-cls = _initElementClass("selectionDivergence", "sfcObjects_selectionDivergence", "single")
+cls = _initElementClass("selectionDivergence", "sfcObjects", "single")
if cls:
setattr(cls, "getinfos", _getdivergenceinfosFunction(True, False))
-cls = _initElementClass("selectionConvergence", "sfcObjects_selectionConvergence", "multiple")
+cls = _initElementClass("selectionConvergence", "sfcObjects", "multiple")
if cls:
setattr(cls, "getinfos", _getdivergenceinfosFunction(False, False))
-cls = _initElementClass("simultaneousDivergence", "sfcObjects_simultaneousDivergence", "single")
+cls = _initElementClass("simultaneousDivergence", "sfcObjects", "single")
if cls:
setattr(cls, "getinfos", _getdivergenceinfosFunction(True, True))
-cls = _initElementClass("simultaneousConvergence", "sfcObjects_simultaneousConvergence", "multiple")
+cls = _initElementClass("simultaneousConvergence", "sfcObjects", "multiple")
if cls:
setattr(cls, "getinfos", _getdivergenceinfosFunction(False, True))
-cls = _initElementClass("jumpStep", "sfcObjects_jumpStep", "single")
+cls = _initElementClass("jumpStep", "sfcObjects", "single")
if cls:
def getinfos(self):
infos = _getelementinfos(self)
@@ -2537,7 +2293,7 @@
return _Search([("target", self.gettargetName())], criteria, parent_infos + ["jump", self.getlocalId()])
setattr(cls, "Search", Search)
-cls = PLCOpenClasses.get("actionBlock_action", None)
+cls = PLCOpenParser.GetElementClass("action", "actionBlock")
if cls:
def compatibility(self, tree):
relPosition = reduce(lambda x, y: x | (y.nodeName == "relPosition"), tree.childNodes, False)
@@ -2551,39 +2307,39 @@
setattr(cls, "compatibility", compatibility)
def setreferenceName(self, name):
- if self.reference:
+ if self.reference is not None:
self.reference.setname(name)
setattr(cls, "setreferenceName", setreferenceName)
def getreferenceName(self):
- if self.reference:
+ if self.reference is not None:
return self.reference.getname()
return None
setattr(cls, "getreferenceName", getreferenceName)
def setinlineContent(self, content):
- if self.inline:
- self.inline.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
+ if self.inline is not None:
+ self.inline.setcontent(PLCOpenParser.CreateElement("ST", "inline"))
self.inline.settext(content)
setattr(cls, "setinlineContent", setinlineContent)
def getinlineContent(self):
- if self.inline:
+ if self.inline is not None:
return self.inline.gettext()
return None
setattr(cls, "getinlineContent", getinlineContent)
def updateElementName(self, old_name, new_name):
- if self.reference and self.reference.getname() == old_name:
+ if self.reference is not None and self.reference.getname() == old_name:
self.reference.setname(new_name)
- if self.inline:
+ if self.inline is not None:
self.inline.updateElementName(old_name, new_name)
setattr(cls, "updateElementName", updateElementName)
def updateElementAddress(self, address_model, new_leading):
- if self.reference:
+ if self.reference is not None:
self.reference.setname(update_address(self.reference.getname(), address_model, new_leading))
- if self.inline:
+ if self.inline is not None:
self.inline.updateElementAddress(address_model, new_leading)
setattr(cls, "updateElementAddress", updateElementAddress)
@@ -2599,7 +2355,7 @@
criteria, parent_infos)
setattr(cls, "Search", Search)
-cls = _initElementClass("actionBlock", "commonObjects_actionBlock", "single")
+cls = _initElementClass("actionBlock", "commonObjects", "single")
if cls:
def compatibility(self, tree):
for child in tree.childNodes[:]:
@@ -2618,7 +2374,8 @@
def setactions(self, actions):
self.action = []
for params in actions:
- action = PLCOpenClasses["actionBlock_action"]()
+ action = PLCOpenParser.CreateElement("action", "actionBlock")
+ self.appendaction(action)
action.setqualifier(params["qualifier"])
if params["type"] == "reference":
action.addreference()
@@ -2630,7 +2387,6 @@
action.setduration(params["duration"])
if params.has_key("indicator"):
action.setindicator(params["indicator"])
- self.action.append(action)
setattr(cls, "setactions", setactions)
def getactions(self):
@@ -2640,17 +2396,17 @@
params["qualifier"] = action.getqualifier()
if params["qualifier"] is None:
params["qualifier"] = "N"
- if action.getreference():
+ if action.getreference() is not None:
params["type"] = "reference"
params["value"] = action.getreferenceName()
- elif action.getinline():
+ elif action.getinline() is not None:
params["type"] = "inline"
params["value"] = action.getinlineContent()
duration = action.getduration()
if duration:
params["duration"] = duration
indicator = action.getindicator()
- if indicator:
+ if indicator is not None:
params["indicator"] = indicator
actions.append(params)
return actions
@@ -2675,58 +2431,41 @@
setattr(cls, "Search", Search)
def _SearchInIOVariable(self, criteria, parent_infos=[]):
- return _Search([("expression", self.getexpression())], criteria, parent_infos + ["io_variable", self.getlocalId()])
-
-cls = _initElementClass("inVariable", "fbdObjects_inVariable")
+ return _Search([("expression", self.expression.text)], criteria, parent_infos + ["io_variable", self.getlocalId()])
+
+def _UpdateIOElementName(self, old_name, new_name):
+ if self.expression.text == old_name:
+ self.expression.text = new_name
+
+def _UpdateIOElementAddress(self, old_name, new_name):
+ self.expression.text = update_address(self.expression.text, address_model, new_leading)
+
+cls = _initElementClass("inVariable", "fbdObjects")
if cls:
setattr(cls, "getinfos", _getvariableinfosFunction("input", False, True))
-
- def updateElementName(self, old_name, new_name):
- if self.expression == old_name:
- self.expression = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.expression = update_address(self.expression, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
+ setattr(cls, "updateElementName", _UpdateIOElementName)
+ setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
setattr(cls, "Search", _SearchInIOVariable)
-cls = _initElementClass("outVariable", "fbdObjects_outVariable", "single")
+cls = _initElementClass("outVariable", "fbdObjects", "single")
if cls:
setattr(cls, "getinfos", _getvariableinfosFunction("output", True, False))
-
- def updateElementName(self, old_name, new_name):
- if self.expression == old_name:
- self.expression = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.expression = update_address(self.expression, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
+ setattr(cls, "updateElementName", _UpdateIOElementName)
+ setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
setattr(cls, "Search", _SearchInIOVariable)
-cls = _initElementClass("inOutVariable", "fbdObjects_inOutVariable", "single")
+cls = _initElementClass("inOutVariable", "fbdObjects", "single")
if cls:
setattr(cls, "getinfos", _getvariableinfosFunction("inout", True, True))
-
- def updateElementName(self, old_name, new_name):
- if self.expression == old_name:
- self.expression = new_name
- setattr(cls, "updateElementName", updateElementName)
-
- def updateElementAddress(self, address_model, new_leading):
- self.expression = update_address(self.expression, address_model, new_leading)
- setattr(cls, "updateElementAddress", updateElementAddress)
-
+ setattr(cls, "updateElementName", _UpdateIOElementName)
+ setattr(cls, "updateElementAddress", _UpdateIOElementAddress)
setattr(cls, "Search", _SearchInIOVariable)
def _SearchInConnector(self, criteria, parent_infos=[]):
return _Search([("name", self.getname())], criteria, parent_infos + ["connector", self.getlocalId()])
-cls = _initElementClass("continuation", "commonObjects_continuation")
+cls = _initElementClass("continuation", "commonObjects")
if cls:
setattr(cls, "getinfos", _getconnectorinfosFunction("continuation"))
setattr(cls, "Search", _SearchInConnector)
@@ -2736,7 +2475,7 @@
self.name = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = _initElementClass("connector", "commonObjects_connector", "single")
+cls = _initElementClass("connector", "commonObjects", "single")
if cls:
setattr(cls, "getinfos", _getconnectorinfosFunction("connector"))
setattr(cls, "Search", _SearchInConnector)
@@ -2746,15 +2485,16 @@
self.name = new_name
setattr(cls, "updateElementName", updateElementName)
-cls = PLCOpenClasses.get("connection", None)
+cls = PLCOpenParser.GetElementClass("connection")
if cls:
def setpoints(self, points):
- self.position = []
+ positions = []
for point in points:
- position = PLCOpenClasses["position"]()
+ position = PLCOpenParser.CreateElement("position", "connection")
position.setx(point.x)
position.sety(point.y)
- self.position.append(position)
+ positions.append(position)
+ self.position = positions
setattr(cls, "setpoints", setpoints)
def getpoints(self):
@@ -2764,111 +2504,115 @@
return points
setattr(cls, "getpoints", getpoints)
-cls = PLCOpenClasses.get("connectionPointIn", None)
+cls = PLCOpenParser.GetElementClass("connectionPointIn")
if cls:
def setrelPositionXY(self, x, y):
- self.relPosition = PLCOpenClasses["position"]()
+ self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointIn")
self.relPosition.setx(x)
self.relPosition.sety(y)
setattr(cls, "setrelPositionXY", setrelPositionXY)
def getrelPositionXY(self):
- if self.relPosition:
+ if self.relPosition is not None:
return self.relPosition.getx(), self.relPosition.gety()
- else:
- return self.relPosition
+ return self.relPosition
setattr(cls, "getrelPositionXY", getrelPositionXY)
def addconnection(self):
- if not self.content:
- self.content = {"name" : "connection", "value" : [PLCOpenClasses["connection"]()]}
- else:
- self.content["value"].append(PLCOpenClasses["connection"]())
+ self.append(PLCOpenParser.CreateElement("connection", "connectionPointIn"))
setattr(cls, "addconnection", addconnection)
def removeconnection(self, idx):
- if self.content:
- self.content["value"].pop(idx)
- if len(self.content["value"]) == 0:
- self.content = None
+ if len(self.content) > idx:
+ self.remove(self.content[idx])
setattr(cls, "removeconnection", removeconnection)
def removeconnections(self):
- if self.content:
- self.content = None
+ self.content = None
setattr(cls, "removeconnections", removeconnections)
+ connection_xpath = PLCOpen_XPath("ppx:connection")
+ connection_by_position_xpath = PLCOpen_XPath("ppx:connection[position()=$pos]")
def getconnections(self):
- if self.content:
- return self.content["value"]
- return []
+ return connection_xpath(self)
setattr(cls, "getconnections", getconnections)
- def setconnectionId(self, idx, id):
- if self.content:
- self.content["value"][idx].setrefLocalId(id)
+ def getconnection(self, idx):
+ connection = connection_by_position_xpath(self, pos=idx+1)
+ if len(connection) > 0:
+ return connection[0]
+ return None
+ setattr(cls, "getconnection", getconnection)
+
+ def setconnectionId(self, idx, local_id):
+ connection = self.getconnection(idx)
+ if connection is not None:
+ connection.setrefLocalId(local_id)
setattr(cls, "setconnectionId", setconnectionId)
def getconnectionId(self, idx):
- if self.content:
- return self.content["value"][idx].getrefLocalId()
+ connection = self.getconnection(idx)
+ if connection is not None:
+ return connection.getrefLocalId()
return None
setattr(cls, "getconnectionId", getconnectionId)
def setconnectionPoints(self, idx, points):
- if self.content:
- self.content["value"][idx].setpoints(points)
+ connection = self.getconnection(idx)
+ if connection is not None:
+ connection.setpoints(points)
setattr(cls, "setconnectionPoints", setconnectionPoints)
def getconnectionPoints(self, idx):
- if self.content:
- return self.content["value"][idx].getpoints()
+ connection = self.getconnection(idx)
+ if connection is not None:
+ return connection.getpoints()
return []
setattr(cls, "getconnectionPoints", getconnectionPoints)
def setconnectionParameter(self, idx, parameter):
- if self.content:
- self.content["value"][idx].setformalParameter(parameter)
+ connection = self.getconnection(idx)
+ if connection is not None:
+ connection.setformalParameter(parameter)
setattr(cls, "setconnectionParameter", setconnectionParameter)
def getconnectionParameter(self, idx):
- if self.content:
- return self.content["value"][idx].getformalParameter()
+ connection = self.getconnection(idx)
+ if connection is not None:
+ return connection.getformalParameter()
return None
setattr(cls, "getconnectionParameter", getconnectionParameter)
-cls = PLCOpenClasses.get("connectionPointOut", None)
+cls = PLCOpenParser.GetElementClass("connectionPointOut")
if cls:
def setrelPositionXY(self, x, y):
- self.relPosition = PLCOpenClasses["position"]()
+ self.relPosition = PLCOpenParser.CreateElement("relPosition", "connectionPointOut")
self.relPosition.setx(x)
self.relPosition.sety(y)
setattr(cls, "setrelPositionXY", setrelPositionXY)
def getrelPositionXY(self):
- if self.relPosition:
+ if self.relPosition is not None:
return self.relPosition.getx(), self.relPosition.gety()
return self.relPosition
setattr(cls, "getrelPositionXY", getrelPositionXY)
-cls = PLCOpenClasses.get("value", None)
+cls = PLCOpenParser.GetElementClass("value")
if cls:
def setvalue(self, value):
value = value.strip()
if value.startswith("[") and value.endswith("]"):
- arrayValue = PLCOpenClasses["value_arrayValue"]()
- self.content = {"name" : "arrayValue", "value" : arrayValue}
+ content = PLCOpenParser.CreateElement("arrayValue", "value")
elif value.startswith("(") and value.endswith(")"):
- structValue = PLCOpenClasses["value_structValue"]()
- self.content = {"name" : "structValue", "value" : structValue}
+ content = PLCOpenParser.CreateElement("structValue", "value")
else:
- simpleValue = PLCOpenClasses["value_simpleValue"]()
- self.content = {"name" : "simpleValue", "value": simpleValue}
- self.content["value"].setvalue(value)
+ content = PLCOpenParser.CreateElement("simpleValue", "value")
+ content.setvalue(value)
+ self.setcontent(content)
setattr(cls, "setvalue", setvalue)
def getvalue(self):
- return self.content["value"].getvalue()
+ return self.content.getvalue()
setattr(cls, "getvalue", getvalue)
def extractValues(values):
@@ -2885,15 +2629,15 @@
raise ValueError, _("\"%s\" is an invalid value!")%value
return items
-cls = PLCOpenClasses.get("value_arrayValue", None)
+cls = PLCOpenParser.GetElementClass("arrayValue", "value")
if cls:
arrayValue_model = re.compile("([0-9]*)\((.*)\)$")
def setvalue(self, value):
- self.value = []
+ elements = []
for item in extractValues(value[1:-1]):
item = item.strip()
- element = PLCOpenClasses["arrayValue_value"]()
+ element = PLCOpenParser.CreateElement("value", "arrayValue")
result = arrayValue_model.match(item)
if result is not None:
groups = result.groups()
@@ -2901,14 +2645,18 @@
element.setvalue(groups[1].strip())
else:
element.setvalue(item)
- self.value.append(element)
+ elements.append(element)
+ self.value = elements
setattr(cls, "setvalue", setvalue)
def getvalue(self):
values = []
for element in self.value:
- repetition = element.getrepetitionValue()
- if repetition is not None and int(repetition) > 1:
+ try:
+ repetition = int(element.getrepetitionValue())
+ except:
+ repetition = 1
+ if repetition > 1:
value = element.getvalue()
if value is None:
value = ""
@@ -2918,20 +2666,21 @@
return "[%s]"%", ".join(values)
setattr(cls, "getvalue", getvalue)
-cls = PLCOpenClasses.get("value_structValue", None)
+cls = PLCOpenParser.GetElementClass("structValue", "value")
if cls:
structValue_model = re.compile("(.*):=(.*)")
def setvalue(self, value):
- self.value = []
+ elements = []
for item in extractValues(value[1:-1]):
result = structValue_model.match(item)
if result is not None:
groups = result.groups()
- element = PLCOpenClasses["structValue_value"]()
+ element = PLCOpenParser.CreateElement("value", "structValue")
element.setmember(groups[0].strip())
element.setvalue(groups[1].strip())
- self.value.append(element)
+ elements.append(element)
+ self.value = elements
setattr(cls, "setvalue", setvalue)
def getvalue(self):
@@ -2940,3 +2689,4 @@
values.append("%s := %s"%(element.getmember(), element.getvalue()))
return "(%s)"%", ".join(values)
setattr(cls, "getvalue", getvalue)
+
--- a/plcopen/structures.py Wed Sep 04 00:06:44 2013 +0200
+++ b/plcopen/structures.py Mon Sep 09 00:48:34 2013 +0200
@@ -42,7 +42,7 @@
return mylist
def generate_block(generator, block, block_infos, body, link, order=False, to_inout=False):
- body_type = body.getcontent()["name"]
+ body_type = body.getcontent().getLocalTag()
name = block.getinstanceName()
type = block.gettypeName()
executionOrderId = block.getexecutionOrderId()
@@ -158,7 +158,7 @@
generator.Program += JoinList([(", ", ())], vars)
generator.Program += [(");\n", ())]
- if link:
+ if link is not None:
connectionPoint = link.getposition()[-1]
output_parameter = link.getformalParameter()
else:
@@ -177,7 +177,7 @@
else:
for i, variable in enumerate(output_variables):
blockPointx, blockPointy = variable.connectionPointOut.getrelPositionXY()
- if (not connectionPoint or
+ if (connectionPoint is None or
block.getx() + blockPointx == connectionPoint.getx() and
block.gety() + blockPointy == connectionPoint.gety()):
output_variable = variable
--- a/xmlclass/__init__.py Wed Sep 04 00:06:44 2013 +0200
+++ b/xmlclass/__init__.py Mon Sep 09 00:48:34 2013 +0200
@@ -24,5 +24,5 @@
# Package initialisation
-from xmlclass import ClassFactory, GenerateClasses, GetAttributeValue, time_model, CreateNode, NodeSetAttr, NodeRenameAttr, UpdateXMLClassGlobals
-from xsdschema import XSDClassFactory, GenerateClassesFromXSD, GenerateClassesFromXSDstring
+from xmlclass import ClassFactory, GenerateParser, DefaultElementClass, GetAttributeValue, time_model, CreateNode, NodeSetAttr, NodeRenameAttr
+from xsdschema import XSDClassFactory, GenerateParserFromXSD, GenerateParserFromXSDstring
--- a/xmlclass/xmlclass.py Wed Sep 04 00:06:44 2013 +0200
+++ b/xmlclass/xmlclass.py Mon Sep 09 00:48:34 2013 +0200
@@ -28,7 +28,9 @@
from types import *
from xml.dom import minidom
from xml.sax.saxutils import escape, unescape, quoteattr
+from lxml import etree
from new import classobj
+from collections import OrderedDict
def CreateNode(name):
node = minidom.Node()
@@ -533,28 +535,33 @@
return GetModelNameList
def GenerateAnyInfos(infos):
+
+ def GetTextElement(tree):
+ if infos["namespace"][0] == "##any":
+ return tree.xpath("p")[0]
+ return tree.xpath("ns:p", namespaces={"ns": infos["namespace"][0]})[0]
+
def ExtractAny(tree):
- if tree.nodeName in ["#text", "#cdata-section"]:
- return unicode(unescape(tree.data))
- else:
- return tree
-
- def GenerateAny(value, name=None, indent=0):
- if isinstance(value, (StringType, UnicodeType)):
- try:
- value = value.decode("utf-8")
- except:
- pass
- return u'<![CDATA[%s]]>\n' % value
- else:
- return value.toprettyxml(indent=" "*indent, encoding="utf-8")
+ return GetTextElement(tree).text
+
+ def GenerateAny(tree, value):
+ GetTextElement(tree).text = etree.CDATA(value)
+
+ def InitialAny():
+ if infos["namespace"][0] == "##any":
+ element_name = "p"
+ else:
+ element_name = "{%s}p" % infos["namespace"][0]
+ p = etree.Element(element_name)
+ p.text = etree.CDATA("")
+ return p
return {
"type": COMPLEXTYPE,
"extract": ExtractAny,
"generate": GenerateAny,
- "initial": lambda: "",
- "check": lambda x: isinstance(x, (StringType, UnicodeType, minidom.Node))
+ "initial": InitialAny,
+ "check": lambda x: isinstance(x, (StringType, UnicodeType, etree.ElementBase))
}
def GenerateTagInfos(infos):
@@ -591,38 +598,23 @@
def GetElementInitialValue(factory, infos):
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if infos["minOccurs"] == 0 and infos["maxOccurs"] == 1:
- if infos.has_key("default"):
- return infos["elmt_type"]["extract"](infos["default"], False)
- else:
- return None
- elif infos["minOccurs"] == 1 and infos["maxOccurs"] == 1:
- return infos["elmt_type"]["initial"]()
+ if infos["minOccurs"] == 1:
+ element_name = factory.etreeNamespaceFormat % infos["name"]
+ if infos["elmt_type"]["type"] == SIMPLETYPE:
+ def initial_value():
+ value = etree.Element(element_name)
+ value.text = (infos["elmt_type"]["generate"](infos["elmt_type"]["initial"]()))
+ return value
+ else:
+ def initial_value():
+ value = infos["elmt_type"]["initial"]()
+ if infos["type"] != ANY:
+ DefaultElementClass.__setattr__(value, "tag", element_name)
+ value.init()
+ return value
+ return [initial_value() for i in xrange(infos["minOccurs"])]
else:
- return [infos["elmt_type"]["initial"]() for i in xrange(infos["minOccurs"])]
-
-def HandleError(message, raise_exception):
- if raise_exception:
- raise ValueError(message)
- return False
-
-def CheckElementValue(factory, name, infos, value, raise_exception=True):
- infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if value is None and raise_exception:
- if not (infos["minOccurs"] == 0 and infos["maxOccurs"] == 1):
- return HandleError("Attribute '%s' isn't optional." % name, raise_exception)
- elif infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:
- if not isinstance(value, ListType):
- return HandleError("Attribute '%s' must be a list." % name, raise_exception)
- if len(value) < infos["minOccurs"] or infos["maxOccurs"] != "unbounded" and len(value) > infos["maxOccurs"]:
- return HandleError("List out of bounds for attribute '%s'." % name, raise_exception)
- if not reduce(lambda x, y: x and y, map(infos["elmt_type"]["check"], value), True):
- return HandleError("Attribute '%s' must be a list of valid elements." % name, raise_exception)
- elif infos.has_key("fixed") and value != infos["fixed"]:
- return HandleError("Value of attribute '%s' can only be '%s'." % (name, str(infos["fixed"])), raise_exception)
- else:
- return infos["elmt_type"]["check"](value)
- return True
+ return []
def GetContentInfos(name, choices):
for choice_infos in choices:
@@ -649,6 +641,7 @@
sequence_element["elmt_type"] = element_infos
elif choice["elmt_type"] == "tag":
choice["elmt_type"] = GenerateTagInfos(choice)
+ factory.AddToLookupClass(choice["name"], name, DefaultElementClass)
else:
choice_infos = factory.ExtractTypeInfos(choice["name"], name, choice["elmt_type"])
if choice_infos is not None:
@@ -656,26 +649,6 @@
choices.append((choice["name"], choice))
return choices
-def ExtractContentElement(factory, tree, infos, content):
- infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:
- if isinstance(content, ListType) and len(content) > 0 and \
- content[-1]["name"] == tree.nodeName:
- content_item = content.pop(-1)
- content_item["value"].append(infos["elmt_type"]["extract"](tree))
- return content_item
- elif not isinstance(content, ListType) and \
- content is not None and \
- content["name"] == tree.nodeName:
- return {"name": tree.nodeName,
- "value": content["value"] + [infos["elmt_type"]["extract"](tree)]}
- else:
- return {"name": tree.nodeName,
- "value": [infos["elmt_type"]["extract"](tree)]}
- else:
- return {"name": tree.nodeName,
- "value": infos["elmt_type"]["extract"](tree)}
-
def GenerateContentInfos(factory, name, choices):
choices_dict = {}
for choice_name, infos in choices:
@@ -691,6 +664,7 @@
if choices_dict.has_key(choice_name):
raise ValueError("'%s' element defined two times in choice" % choice_name)
choices_dict[choice_name] = infos
+ choices_xpath = "|".join(map(lambda x: "%s:%s" % (factory.TargetNamespace, x), choices_dict.keys()))
def GetContentInitial():
content_name, infos = choices[0]
@@ -698,140 +672,15 @@
content_value = []
for i in xrange(infos["minOccurs"]):
for element_infos in infos["elements"]:
- value = GetElementInitialValue(factory, element_infos)
- if value is not None:
- if element_infos["type"] == CHOICE:
- content_value.append(value)
- else:
- content_value.append({"name": element_infos["name"], "value": value})
+ content_value.extend(GetElementInitialValue(factory, element_infos))
else:
content_value = GetElementInitialValue(factory, infos)
- return {"name": content_name, "value": content_value}
-
- def CheckContent(value):
- if value["name"] != "sequence":
- infos = choices_dict.get(value["name"], None)
- if infos is not None:
- return CheckElementValue(factory, value["name"], infos, value["value"], False)
- elif len(value["value"]) > 0:
- infos = choices_dict.get(value["value"][0]["name"], None)
- if infos is None:
- for choice_name, infos in choices:
- if infos["type"] == "sequence":
- for element_infos in infos["elements"]:
- if element_infos["type"] == CHOICE:
- infos = GetContentInfos(value["value"][0]["name"], element_infos["choices"])
- if infos is not None:
- sequence_number = 0
- element_idx = 0
- while element_idx < len(value["value"]):
- for element_infos in infos["elements"]:
- element_value = None
- if element_infos["type"] == CHOICE:
- choice_infos = None
- if element_idx < len(value["value"]):
- for choice in element_infos["choices"]:
- if choice["name"] == value["value"][element_idx]["name"]:
- choice_infos = choice
- element_value = value["value"][element_idx]["value"]
- element_idx += 1
- break
- if ((choice_infos is not None and
- not CheckElementValue(factory, choice_infos["name"], choice_infos, element_value, False)) or
- (choice_infos is None and element_infos["minOccurs"] > 0)):
- raise ValueError("Invalid sequence value in attribute 'content'")
- else:
- if element_idx < len(value["value"]) and element_infos["name"] == value["value"][element_idx]["name"]:
- element_value = value["value"][element_idx]["value"]
- element_idx += 1
- if not CheckElementValue(factory, element_infos["name"], element_infos, element_value, False):
- raise ValueError("Invalid sequence value in attribute 'content'")
- sequence_number += 1
- if sequence_number < infos["minOccurs"] or infos["maxOccurs"] != "unbounded" and sequence_number > infos["maxOccurs"]:
- raise ValueError("Invalid sequence value in attribute 'content'")
- return True
- else:
- for element_name, infos in choices:
- if element_name == "sequence":
- required = 0
- for element in infos["elements"]:
- if element["minOccurs"] > 0:
- required += 1
- if required == 0:
- return True
- return False
-
- def ExtractContent(tree, content):
- infos = choices_dict.get(tree.nodeName, None)
- if infos is not None:
- if infos["name"] == "sequence":
- sequence_dict = dict([(element_infos["name"], element_infos) for element_infos in infos["elements"] if element_infos["type"] != CHOICE])
- element_infos = sequence_dict.get(tree.nodeName)
- if content is not None and \
- content["name"] == "sequence" and \
- len(content["value"]) > 0 and \
- choices_dict.get(content["value"][-1]["name"]) == infos:
- return {"name": "sequence",
- "value": content["value"] + [ExtractContentElement(factory, tree, element_infos, content["value"][-1])]}
- else:
- return {"name": "sequence",
- "value": [ExtractContentElement(factory, tree, element_infos, None)]}
- else:
- return ExtractContentElement(factory, tree, infos, content)
- else:
- for choice_name, infos in choices:
- if infos["type"] == "sequence":
- for element_infos in infos["elements"]:
- if element_infos["type"] == CHOICE:
- try:
- if content is not None and \
- content["name"] == "sequence" and \
- len(content["value"]) > 0:
- return {"name": "sequence",
- "value": content["value"] + [element_infos["elmt_type"]["extract"](tree, content["value"][-1])]}
- else:
- return {"name": "sequence",
- "value": [element_infos["elmt_type"]["extract"](tree, None)]}
- except:
- pass
- raise ValueError("Invalid element \"%s\" for content!" % tree.nodeName)
-
- def GenerateContent(value, name=None, indent=0):
- text = ""
- if value["name"] != "sequence":
- infos = choices_dict.get(value["name"], None)
- if infos is not None:
- infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- if infos["maxOccurs"] == "unbounded" or infos["maxOccurs"] > 1:
- for item in value["value"]:
- text += infos["elmt_type"]["generate"](item, value["name"], indent)
- else:
- text += infos["elmt_type"]["generate"](value["value"], value["name"], indent)
- elif len(value["value"]) > 0:
- infos = choices_dict.get(value["value"][0]["name"], None)
- if infos is None:
- for choice_name, infos in choices:
- if infos["type"] == "sequence":
- for element_infos in infos["elements"]:
- if element_infos["type"] == CHOICE:
- infos = GetContentInfos(value["value"][0]["name"], element_infos["choices"])
- if infos is not None:
- sequence_dict = dict([(element_infos["name"], element_infos) for element_infos in infos["elements"]])
- for element_value in value["value"]:
- element_infos = sequence_dict.get(element_value["name"])
- if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
- for item in element_value["value"]:
- text += element_infos["elmt_type"]["generate"](item, element_value["name"], indent)
- else:
- text += element_infos["elmt_type"]["generate"](element_value["value"], element_infos["name"], indent)
- return text
+ return content_value
return {
"type": COMPLEXTYPE,
+ "choices_xpath": etree.XPath(choices_xpath, namespaces=factory.NSMAP),
"initial": GetContentInitial,
- "check": CheckContent,
- "extract": ExtractContent,
- "generate": GenerateContent
}
#-------------------------------------------------------------------------------
@@ -901,9 +750,11 @@
self.XMLClassDefinitions = {}
self.DefinedNamespaces = {}
+ self.NSMAP = {}
self.Namespaces = {}
self.SchemaNamespace = None
self.TargetNamespace = None
+ self.etreeNamespaceFormat = "%s"
self.CurrentCompilations = []
@@ -914,6 +765,8 @@
else:
self.ComputedClasses = {}
self.ComputedClassesInfos = {}
+ self.ComputedClassesLookUp = {}
+ self.EquivalentClassesParent = {}
self.AlreadyComputed = {}
def GetQualifiedNameInfos(self, name, namespace=None, canbenone=False):
@@ -1016,7 +869,9 @@
attrs[name] = infos["extract"]["default"](attr)
elif namespace == "xmlns":
infos = self.GetQualifiedNameInfos("anyURI", self.SchemaNamespace)
- self.DefinedNamespaces[infos["extract"](attr)] = name
+ value = infos["extract"](attr)
+ self.DefinedNamespaces[value] = name
+ self.NSMAP[name] = value
else:
raise ValueError("Invalid attribute \"%s\" for member \"%s\"!" % (qualified_name, node.nodeName))
for attr in valid_attrs:
@@ -1063,20 +918,48 @@
def ParseSchema(self):
pass
-
+
+ def AddEquivalentClass(self, name, base):
+ if name != base:
+ equivalences = self.EquivalentClassesParent.setdefault(self.etreeNamespaceFormat % base, {})
+ equivalences[self.etreeNamespaceFormat % name] = True
+
+ def AddToLookupClass(self, name, parent, typeinfos):
+ lookup_name = self.etreeNamespaceFormat % name
+ if isinstance(typeinfos, (StringType, UnicodeType)):
+ self.AddEquivalentClass(name, typeinfos)
+ typeinfos = self.etreeNamespaceFormat % typeinfos
+ lookup_classes = self.ComputedClassesLookUp.get(lookup_name)
+ if lookup_classes is None:
+ self.ComputedClassesLookUp[lookup_name] = (typeinfos, parent)
+ elif isinstance(lookup_classes, DictType):
+ lookup_classes[self.etreeNamespaceFormat % parent
+ if parent is not None else None] = typeinfos
+ else:
+ lookup_classes = {self.etreeNamespaceFormat % lookup_classes[1]
+ if lookup_classes[1] is not None else None: lookup_classes[0]}
+ lookup_classes[self.etreeNamespaceFormat % parent
+ if parent is not None else None] = typeinfos
+ self.ComputedClassesLookUp[lookup_name] = lookup_classes
+
def ExtractTypeInfos(self, name, parent, typeinfos):
if isinstance(typeinfos, (StringType, UnicodeType)):
- namespace, name = DecomposeQualifiedName(typeinfos)
- infos = self.GetQualifiedNameInfos(name, namespace)
+ namespace, type_name = DecomposeQualifiedName(typeinfos)
+ infos = self.GetQualifiedNameInfos(type_name, namespace)
+ if name != "base":
+ if infos["type"] == SIMPLETYPE:
+ self.AddToLookupClass(name, parent, DefaultElementClass)
+ elif namespace == self.TargetNamespace:
+ self.AddToLookupClass(name, parent, type_name)
if infos["type"] == COMPLEXTYPE:
- name, parent = self.SplitQualifiedName(name, namespace)
- result = self.CreateClass(name, parent, infos)
+ type_name, parent = self.SplitQualifiedName(type_name, namespace)
+ result = self.CreateClass(type_name, parent, infos)
if result is not None and not isinstance(result, (UnicodeType, StringType)):
self.Namespaces[self.TargetNamespace][result["name"]] = result
return result
elif infos["type"] == ELEMENT and infos["elmt_type"]["type"] == COMPLEXTYPE:
- name, parent = self.SplitQualifiedName(name, namespace)
- result = self.CreateClass(name, parent, infos["elmt_type"])
+ type_name, parent = self.SplitQualifiedName(type_name, namespace)
+ result = self.CreateClass(type_name, parent, infos["elmt_type"])
if result is not None and not isinstance(result, (UnicodeType, StringType)):
self.Namespaces[self.TargetNamespace][result["name"]] = result
return result
@@ -1086,7 +969,12 @@
return self.CreateClass(name, parent, typeinfos)
elif typeinfos["type"] == SIMPLETYPE:
return typeinfos
-
+
+ def GetEquivalentParents(self, parent):
+ return reduce(lambda x, y: x + y,
+ [[p] + self.GetEquivalentParents(p)
+ for p in self.EquivalentClassesParent.get(parent, {}).keys()], [])
+
"""
Methods that generates the classes
"""
@@ -1123,6 +1011,21 @@
if result is not None and \
not isinstance(result, (UnicodeType, StringType)):
self.Namespaces[self.TargetNamespace][result["name"]] = result
+
+ for name, parents in self.ComputedClassesLookUp.iteritems():
+ if isinstance(parents, DictType):
+ computed_classes = parents.items()
+ elif parents[1] is not None:
+ computed_classes = [(self.etreeNamespaceFormat % parents[1], parents[0])]
+ else:
+ computed_classes = []
+ for parent, computed_class in computed_classes:
+ for equivalent_parent in self.GetEquivalentParents(parent):
+ if not isinstance(parents, DictType):
+ parents = dict(computed_classes)
+ self.ComputedClassesLookUp[name] = parents
+ parents[equivalent_parent] = computed_class
+
return self.ComputedClasses
def CreateClass(self, name, parent, classinfos, baseclass = False):
@@ -1141,9 +1044,12 @@
bases = []
base_infos = classinfos.get("base", None)
if base_infos is not None:
+ namespace, base_name = DecomposeQualifiedName(base_infos)
+ if namespace == self.TargetNamespace:
+ self.AddEquivalentClass(name, base_name)
result = self.ExtractTypeInfos("base", name, base_infos)
if result is None:
- namespace, base_name = DecomposeQualifiedName(base_infos)
+ namespace, base_name = DecomposeQualifiedName(base_infos)
if self.AlreadyComputed.get(base_name, False):
self.ComputeAfter.append((name, parent, classinfos))
if self.TargetNamespace is not None:
@@ -1164,7 +1070,7 @@
if classinfos["base"] is None:
raise ValueError("No class found for base type")
bases.append(classinfos["base"])
- bases.append(object)
+ bases.append(DefaultElementClass)
bases = tuple(bases)
classmembers = {"__doc__": classinfos.get("doc", ""), "IsBaseClass": baseclass}
@@ -1177,11 +1083,8 @@
raise ValueError("\"%s\" type is not a simple type!" % attribute["attr_type"])
attrname = attribute["name"]
if attribute["use"] == "optional":
- classmembers[attrname] = None
classmembers["add%s"%attrname] = generateAddMethod(attrname, self, attribute)
classmembers["delete%s"%attrname] = generateDeleteMethod(attrname)
- else:
- classmembers[attrname] = infos["initial"]()
classmembers["set%s"%attrname] = generateSetMethod(attrname)
classmembers["get%s"%attrname] = generateGetMethod(attrname)
else:
@@ -1200,54 +1103,42 @@
classmembers["set%sbytype" % elmtname] = generateSetChoiceByTypeMethod(self, element["choices"])
infos = GenerateContentInfos(self, name, choices)
elif element["type"] == ANY:
- elmtname = element["name"] = "text"
+ elmtname = element["name"] = "anyText"
element["minOccurs"] = element["maxOccurs"] = 1
infos = GenerateAnyInfos(element)
else:
elmtname = element["name"]
if element["elmt_type"] == "tag":
infos = GenerateTagInfos(element)
+ self.AddToLookupClass(element["name"], name, DefaultElementClass)
else:
infos = self.ExtractTypeInfos(element["name"], name, element["elmt_type"])
if infos is not None:
element["elmt_type"] = infos
if element["maxOccurs"] == "unbounded" or element["maxOccurs"] > 1:
- classmembers[elmtname] = []
classmembers["append%s" % elmtname] = generateAppendMethod(elmtname, element["maxOccurs"], self, element)
classmembers["insert%s" % elmtname] = generateInsertMethod(elmtname, element["maxOccurs"], self, element)
classmembers["remove%s" % elmtname] = generateRemoveMethod(elmtname, element["minOccurs"])
classmembers["count%s" % elmtname] = generateCountMethod(elmtname)
else:
if element["minOccurs"] == 0:
- classmembers[elmtname] = None
classmembers["add%s" % elmtname] = generateAddMethod(elmtname, self, element)
classmembers["delete%s" % elmtname] = generateDeleteMethod(elmtname)
- elif not isinstance(element["elmt_type"], (UnicodeType, StringType)):
- classmembers[elmtname] = element["elmt_type"]["initial"]()
- else:
- classmembers[elmtname] = None
classmembers["set%s" % elmtname] = generateSetMethod(elmtname)
classmembers["get%s" % elmtname] = generateGetMethod(elmtname)
- classmembers["__init__"] = generateInitMethod(self, classinfos)
- classmembers["getStructure"] = generateStructureMethod(classinfos)
- classmembers["loadXMLTree"] = generateLoadXMLTree(self, classinfos)
- classmembers["generateXMLText"] = generateGenerateXMLText(self, classinfos)
+ classmembers["init"] = generateInitMethod(self, classinfos)
classmembers["getElementAttributes"] = generateGetElementAttributes(self, classinfos)
classmembers["getElementInfos"] = generateGetElementInfos(self, classinfos)
classmembers["setElementValue"] = generateSetElementValue(self, classinfos)
- classmembers["singleLineAttributes"] = True
- classmembers["compatibility"] = lambda x, y: None
- classmembers["extraAttrs"] = {}
class_definition = classobj(str(classname), bases, classmembers)
+ setattr(class_definition, "__getattr__", generateGetattrMethod(self, class_definition, classinfos))
setattr(class_definition, "__setattr__", generateSetattrMethod(self, class_definition, classinfos))
class_infos = {"type": COMPILEDCOMPLEXTYPE,
"name": classname,
- "check": generateClassCheckFunction(class_definition),
"initial": generateClassCreateFunction(class_definition),
- "extract": generateClassExtractFunction(class_definition),
- "generate": class_definition.generateXMLText}
+ }
if self.FileName is not None:
self.ComputedClasses[self.FileName][classname] = class_definition
@@ -1255,6 +1146,9 @@
self.ComputedClasses[classname] = class_definition
self.ComputedClassesInfos[classname] = class_infos
+ self.AddToLookupClass(name, parent, class_definition)
+ self.AddToLookupClass(classname, None, class_definition)
+
return class_infos
"""
@@ -1281,14 +1175,6 @@
print classname
"""
-Method that generate the method for checking a class instance
-"""
-def generateClassCheckFunction(class_definition):
- def classCheckfunction(instance):
- return isinstance(instance, class_definition)
- return classCheckfunction
-
-"""
Method that generate the method for creating a class instance
"""
def generateClassCreateFunction(class_definition):
@@ -1296,265 +1182,109 @@
return class_definition()
return classCreatefunction
-"""
-Method that generate the method for extracting a class instance
-"""
-def generateClassExtractFunction(class_definition):
- def classExtractfunction(node):
- instance = class_definition()
- instance.loadXMLTree(node)
- return instance
- return classExtractfunction
-
-"""
-Method that generate the method for loading an xml tree by following the
-attributes list defined
-"""
+def generateGetattrMethod(factory, class_definition, classinfos):
+ attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
+ optional_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "optional"])
+ elements = dict([(element["name"], element) for element in classinfos["elements"]])
+
+ def getattrMethod(self, name):
+ if attributes.has_key(name):
+ attribute_infos = attributes[name]
+ attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"])
+ value = self.get(name)
+ if value is not None:
+ return attribute_infos["attr_type"]["extract"](value, extract=False)
+ elif attribute_infos.has_key("fixed"):
+ return attribute_infos["attr_type"]["extract"](attribute_infos["fixed"], extract=False)
+ elif attribute_infos.has_key("default"):
+ return attribute_infos["attr_type"]["extract"](attribute_infos["default"], extract=False)
+ return None
+
+ elif elements.has_key(name):
+ element_infos = elements[name]
+ element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])
+ if element_infos["type"] == CHOICE:
+ content = element_infos["elmt_type"]["choices_xpath"](self)
+ if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
+ return content
+ elif len(content) > 0:
+ return content[0]
+ return None
+ elif element_infos["type"] == ANY:
+ return element_infos["elmt_type"]["extract"](self)
+ else:
+ element_name = factory.etreeNamespaceFormat % name
+ if element_infos["maxOccurs"] == "unbounded" or element_infos["maxOccurs"] > 1:
+ return self.findall(element_name)
+ else:
+ return self.find(element_name)
+
+ elif classinfos.has_key("base"):
+ return classinfos["base"].__getattr__(self, name)
+
+ return DefaultElementClass.__getattribute__(self, name)
+
+ return getattrMethod
+
def generateSetattrMethod(factory, class_definition, classinfos):
attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
optional_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "optional"])
- elements = dict([(element["name"], element) for element in classinfos["elements"]])
+ elements = OrderedDict([(element["name"], element) for element in classinfos["elements"]])
def setattrMethod(self, name, value):
if attributes.has_key(name):
- attributes[name]["attr_type"] = FindTypeInfos(factory, attributes[name]["attr_type"])
- if value is None:
- if optional_attributes.get(name, False):
- return object.__setattr__(self, name, None)
- else:
- raise ValueError("Attribute '%s' isn't optional." % name)
- elif attributes[name].has_key("fixed") and value != attributes[name]["fixed"]:
- raise ValueError, "Value of attribute '%s' can only be '%s'."%(name, str(attributes[name]["fixed"]))
- elif attributes[name]["attr_type"]["check"](value):
- return object.__setattr__(self, name, value)
+ attribute_infos = attributes[name]
+ attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"])
+ if optional_attributes.get(name, False):
+ default = attribute_infos.get("default", None)
+ if value is None or value == default:
+ self.attrib.pop(name, None)
+ return
+ elif attribute_infos.has_key("fixed"):
+ return
+ return self.set(name, attribute_infos["attr_type"]["generate"](value))
+
+ elif elements.has_key(name):
+ element_infos = elements[name]
+ element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])
+ if element_infos["type"] == ANY:
+ element_infos["elmt_type"]["generate"](self, value)
+
else:
- raise ValueError("Invalid value for attribute '%s'." % (name))
- elif elements.has_key(name):
- if CheckElementValue(factory, name, elements[name], value):
- return object.__setattr__(self, name, value)
- else:
- raise ValueError("Invalid value for attribute '%s'." % (name))
+ element_xpath = ("%s:%s" % (factory.TargetNamespace, name)
+ if name != "content"
+ else elements["content"]["elmt_type"]["choices_xpath"].path)
+
+ for element in self.xpath(element_xpath, namespaces=factory.NSMAP):
+ self.remove(element)
+
+ if value is not None:
+ element_idx = elements.keys().index(name)
+ if element_idx > 0:
+ previous_elements_xpath = "|".join(map(
+ lambda x: "%s:%s" % (factory.TargetNamespace, x)
+ if x != "content"
+ else elements["content"]["elmt_type"]["choices_xpath"].path,
+ elements.keys()[:element_idx]))
+
+ insertion_point = len(self.xpath(previous_elements_xpath, namespaces=factory.NSMAP))
+ else:
+ insertion_point = 0
+
+ if not isinstance(value, ListType):
+ value = [value]
+
+ for element in reversed(value):
+ self.insert(insertion_point, element)
+
elif classinfos.has_key("base"):
return classinfos["base"].__setattr__(self, name, value)
- elif class_definition.__dict__.has_key(name):
- return object.__setattr__(self, name, value)
+
else:
raise AttributeError("'%s' can't have an attribute '%s'." % (self.__class__.__name__, name))
return setattrMethod
-"""
-Method that generate the method for generating the xml tree structure model by
-following the attributes list defined
-"""
-def ComputeMultiplicity(name, infos):
- if infos["minOccurs"] == 0:
- if infos["maxOccurs"] == "unbounded":
- return "(?:%s)*" % name
- elif infos["maxOccurs"] == 1:
- return "(?:%s)?" % name
- else:
- return "(?:%s){,%d}" % (name, infos["maxOccurs"])
- elif infos["minOccurs"] == 1:
- if infos["maxOccurs"] == "unbounded":
- return "(?:%s)+" % name
- elif infos["maxOccurs"] == 1:
- return "(?:%s)" % name
- else:
- return "(?:%s){1,%d}" % (name, infos["maxOccurs"])
- else:
- if infos["maxOccurs"] == "unbounded":
- return "(?:%s){%d,}" % (name, infos["minOccurs"], name)
- else:
- return "(?:%s){%d,%d}" % (name, infos["minOccurs"],
- infos["maxOccurs"])
-
-def GetStructure(classinfos):
- elements = []
- for element in classinfos["elements"]:
- if element["type"] == ANY:
- infos = element.copy()
- infos["minOccurs"] = 0
- elements.append(ComputeMultiplicity("#text |#cdata-section |\w* ", infos))
- elif element["type"] == CHOICE:
- choices = []
- for infos in element["choices"]:
- if infos["type"] == "sequence":
- structure = "(?:%s)" % GetStructure(infos)
- else:
- structure = "%s " % infos["name"]
- choices.append(ComputeMultiplicity(structure, infos))
- elements.append(ComputeMultiplicity("|".join(choices), element))
- elif element["name"] == "content" and element["elmt_type"]["type"] == SIMPLETYPE:
- elements.append("(?:#text |#cdata-section )?")
- else:
- elements.append(ComputeMultiplicity("%s " % element["name"], element))
- if classinfos.get("order", True) or len(elements) == 0:
- return "".join(elements)
- else:
- raise ValueError("XSD structure not yet supported!")
-
-def generateStructureMethod(classinfos):
- def getStructureMethod(self):
- structure = GetStructure(classinfos)
- if classinfos.has_key("base"):
- return classinfos["base"].getStructure(self) + structure
- return structure
- return getStructureMethod
-
-"""
-Method that generate the method for loading an xml tree by following the
-attributes list defined
-"""
-def generateLoadXMLTree(factory, classinfos):
- attributes = dict([(attr["name"], attr) for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
- elements = dict([(element["name"], element) for element in classinfos["elements"]])
-
- def loadXMLTreeMethod(self, tree, extras=[], derived=False):
- self.extraAttrs = {}
- self.compatibility(tree)
- if not derived:
- children_structure = ""
- for node in tree.childNodes:
- if not (node.nodeName == "#text" and node.data.strip() == "") and node.nodeName != "#comment":
- children_structure += "%s " % node.nodeName
- structure_pattern = self.getStructure()
- if structure_pattern != "":
- structure_model = re.compile("(%s)$" % structure_pattern)
- result = structure_model.match(children_structure)
- if not result:
- raise ValueError("Invalid structure for \"%s\" children!." % tree.nodeName)
- required_attributes = dict([(attr["name"], True) for attr in classinfos["attributes"] if attr["use"] == "required"])
- if classinfos.has_key("base"):
- extras.extend([attr["name"] for attr in classinfos["attributes"] if attr["use"] != "prohibited"])
- classinfos["base"].loadXMLTree(self, tree, extras, True)
- for attrname, attr in tree._attrs.iteritems():
- if attributes.has_key(attrname):
- attributes[attrname]["attr_type"] = FindTypeInfos(factory, attributes[attrname]["attr_type"])
- object.__setattr__(self, attrname, attributes[attrname]["attr_type"]["extract"](attr))
- elif not classinfos.has_key("base") and not attrname in extras and not self.extraAttrs.has_key(attrname):
- self.extraAttrs[attrname] = GetAttributeValue(attr)
- required_attributes.pop(attrname, None)
- if len(required_attributes) > 0:
- raise ValueError("Required attributes %s missing for \"%s\" element!" % (", ".join(["\"%s\""%name for name in required_attributes]), tree.nodeName))
- first = {}
- for node in tree.childNodes:
- name = node.nodeName
- if name == "#text" and node.data.strip() == "" or name == "#comment":
- continue
- elif elements.has_key(name):
- elements[name]["elmt_type"] = FindTypeInfos(factory, elements[name]["elmt_type"])
- if elements[name]["maxOccurs"] == "unbounded" or elements[name]["maxOccurs"] > 1:
- if first.get(name, True):
- object.__setattr__(self, name, [elements[name]["elmt_type"]["extract"](node)])
- first[name] = False
- else:
- getattr(self, name).append(elements[name]["elmt_type"]["extract"](node))
- else:
- object.__setattr__(self, name, elements[name]["elmt_type"]["extract"](node))
- elif elements.has_key("text"):
- if elements["text"]["maxOccurs"] == "unbounded" or elements["text"]["maxOccurs"] > 1:
- if first.get("text", True):
- object.__setattr__(self, "text", [elements["text"]["elmt_type"]["extract"](node)])
- first["text"] = False
- else:
- getattr(self, "text").append(elements["text"]["elmt_type"]["extract"](node))
- else:
- object.__setattr__(self, "text", elements["text"]["elmt_type"]["extract"](node))
- elif elements.has_key("content"):
- if name in ["#cdata-section", "#text"]:
- if elements["content"]["elmt_type"]["type"] == SIMPLETYPE:
- object.__setattr__(self, "content", elements["content"]["elmt_type"]["extract"](node.data, False))
- else:
- content = getattr(self, "content")
- if elements["content"]["maxOccurs"] == "unbounded" or elements["content"]["maxOccurs"] > 1:
- if first.get("content", True):
- object.__setattr__(self, "content", [elements["content"]["elmt_type"]["extract"](node, None)])
- first["content"] = False
- else:
- content.append(elements["content"]["elmt_type"]["extract"](node, content))
- else:
- object.__setattr__(self, "content", elements["content"]["elmt_type"]["extract"](node, content))
- return loadXMLTreeMethod
-
-
-"""
-Method that generates the method for generating an xml text by following the
-attributes list defined
-"""
-def generateGenerateXMLText(factory, classinfos):
- def generateXMLTextMethod(self, name, indent=0, extras={}, derived=False):
- ind1, ind2 = getIndent(indent, name)
- if not derived:
- text = ind1 + u'<%s' % name
- else:
- text = u''
-
- first = True
-
- if not classinfos.has_key("base"):
- extras.update(self.extraAttrs)
- for attr, value in extras.iteritems():
- if not first and not self.singleLineAttributes:
- text += u'\n%s' % (ind2)
- text += u' %s=%s' % (attr, quoteattr(value))
- first = False
- extras.clear()
- for attr in classinfos["attributes"]:
- if attr["use"] != "prohibited":
- attr["attr_type"] = FindTypeInfos(factory, attr["attr_type"])
- value = getattr(self, attr["name"], None)
- if value != None:
- computed_value = attr["attr_type"]["generate"](value)
- else:
- computed_value = None
- if attr["use"] != "optional" or (value != None and \
- computed_value != attr.get("default", attr["attr_type"]["generate"](attr["attr_type"]["initial"]()))):
- if classinfos.has_key("base"):
- extras[attr["name"]] = computed_value
- else:
- if not first and not self.singleLineAttributes:
- text += u'\n%s' % (ind2)
- text += ' %s=%s' % (attr["name"], quoteattr(computed_value))
- first = False
- if classinfos.has_key("base"):
- first, new_text = classinfos["base"].generateXMLText(self, name, indent, extras, True)
- text += new_text
- else:
- first = True
- for element in classinfos["elements"]:
- element["elmt_type"] = FindTypeInfos(factory, element["elmt_type"])
- value = getattr(self, element["name"], None)
- if element["minOccurs"] == 0 and element["maxOccurs"] == 1:
- if value is not None:
- if first:
- text += u'>\n'
- first = False
- text += element["elmt_type"]["generate"](value, element["name"], indent + 1)
- elif element["minOccurs"] == 1 and element["maxOccurs"] == 1:
- if first:
- text += u'>\n'
- first = False
- if element["name"] == "content" and element["elmt_type"]["type"] == SIMPLETYPE:
- text += element["elmt_type"]["generate"](value)
- else:
- text += element["elmt_type"]["generate"](value, element["name"], indent + 1)
- else:
- if first and len(value) > 0:
- text += u'>\n'
- first = False
- for item in value:
- text += element["elmt_type"]["generate"](item, element["name"], indent + 1)
- if not derived:
- if first:
- text += u'/>\n'
- else:
- text += ind1 + u'</%s>\n' % (name)
- return text
- else:
- return first, text
- return generateXMLTextMethod
-
def gettypeinfos(name, facets):
if facets.has_key("enumeration") and facets["enumeration"][0] is not None:
return facets["enumeration"][0]
@@ -1723,20 +1453,21 @@
"""
def generateInitMethod(factory, classinfos):
def initMethod(self):
- self.extraAttrs = {}
if classinfos.has_key("base"):
- classinfos["base"].__init__(self)
+ classinfos["base"].init(self)
for attribute in classinfos["attributes"]:
attribute["attr_type"] = FindTypeInfos(factory, attribute["attr_type"])
if attribute["use"] == "required":
- setattr(self, attribute["name"], attribute["attr_type"]["initial"]())
- elif attribute["use"] == "optional":
- if attribute.has_key("default"):
- setattr(self, attribute["name"], attribute["attr_type"]["extract"](attribute["default"], False))
- else:
- setattr(self, attribute["name"], None)
+ self.set(attribute["name"], attribute["attr_type"]["generate"](attribute["attr_type"]["initial"]()))
for element in classinfos["elements"]:
- setattr(self, element["name"], GetElementInitialValue(factory, element))
+ if element["type"] != CHOICE:
+ element_name = (
+ etree.QName(factory.NSMAP["xhtml"], "p")
+ if element["type"] == ANY
+ else factory.etreeNamespaceFormat % element["name"])
+ initial = GetElementInitialValue(factory, element)
+ if initial is not None:
+ map(self.append, initial)
return initMethod
def generateSetMethod(attr):
@@ -1753,18 +1484,16 @@
def addMethod(self):
if infos["type"] == ATTRIBUTE:
infos["attr_type"] = FindTypeInfos(factory, infos["attr_type"])
- initial = infos["attr_type"]["initial"]
- extract = infos["attr_type"]["extract"]
+ if not infos.has_key("default"):
+ setattr(self, attr, infos["attr_type"]["initial"]())
elif infos["type"] == ELEMENT:
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
- initial = infos["elmt_type"]["initial"]
- extract = infos["elmt_type"]["extract"]
+ value = infos["elmt_type"]["initial"]()
+ DefaultElementClass.__setattr__(value, "tag", factory.etreeNamespaceFormat % attr)
+ setattr(self, attr, value)
+ value.init()
else:
raise ValueError("Invalid class attribute!")
- if infos.has_key("default"):
- setattr(self, attr, extract(infos["default"], False))
- else:
- setattr(self, attr, initial())
return addMethod
def generateDeleteMethod(attr):
@@ -1777,10 +1506,10 @@
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
attr_list = getattr(self, attr)
if maxOccurs == "unbounded" or len(attr_list) < maxOccurs:
- if infos["elmt_type"]["check"](value):
- attr_list.append(value)
+ if len(attr_list) == 0:
+ setattr(self, attr, [value])
else:
- raise ValueError("\"%s\" value isn't valid!" % attr)
+ attr_list[-1].addnext(value)
else:
raise ValueError("There can't be more than %d values in \"%s\"!" % (maxOccurs, attr))
return appendMethod
@@ -1790,10 +1519,12 @@
infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])
attr_list = getattr(self, attr)
if maxOccurs == "unbounded" or len(attr_list) < maxOccurs:
- if infos["elmt_type"]["check"](value):
- attr_list.insert(index, value)
+ if len(attr_list) == 0:
+ setattr(self, attr, [value])
+ elif index == 0:
+ attr_list[0].addprevious(value)
else:
- raise ValueError("\"%s\" value isn't valid!" % attr)
+ attr_list[min(index - 1, len(attr_list) - 1)].addnext(value)
else:
raise ValueError("There can't be more than %d values in \"%s\"!" % (maxOccurs, attr))
return insertMethod
@@ -1805,24 +1536,24 @@
def generateSetChoiceByTypeMethod(factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def setChoiceMethod(self, type):
- if not choices.has_key(type):
- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)
- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])
- new_element = choices[type]["elmt_type"]["initial"]()
- self.content = {"name": type, "value": new_element}
- return new_element
+ def setChoiceMethod(self, content_type):
+ if not choices.has_key(content_type):
+ raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)
+ choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])
+ new_content = choices[content_type]["elmt_type"]["initial"]()
+ self.content = new_content
+ return new_content
return setChoiceMethod
def generateAppendChoiceByTypeMethod(maxOccurs, factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def appendChoiceMethod(self, type):
- if not choices.has_key(type):
- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)
- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])
+ def appendChoiceMethod(self, content_type):
+ if not choices.has_key(content_type):
+ raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)
+ choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])
if maxOccurs == "unbounded" or len(self.content) < maxOccurs:
- new_element = choices[type]["elmt_type"]["initial"]()
- self.content.append({"name": type, "value": new_element})
+ new_element = choices[content_type]["elmt_type"]["initial"]()
+ self.appendcontent(new_element)
return new_element
else:
raise ValueError("There can't be more than %d values in \"content\"!" % maxOccurs)
@@ -1830,13 +1561,13 @@
def generateInsertChoiceByTypeMethod(maxOccurs, factory, choice_types):
choices = dict([(choice["name"], choice) for choice in choice_types])
- def insertChoiceMethod(self, index, type):
- if not choices.has_key(type):
- raise ValueError("Unknown \"%s\" choice type for \"content\"!" % type)
- choices[type]["elmt_type"] = FindTypeInfos(factory, choices[type]["elmt_type"])
+ def insertChoiceMethod(self, index, content_type):
+ if not choices.has_key(content_type):
+ raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)
+ choices[type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])
if maxOccurs == "unbounded" or len(self.content) < maxOccurs:
- new_element = choices[type]["elmt_type"]["initial"]()
- self.content.insert(index, {"name" : type, "value" : new_element})
+ new_element = choices[content_type]["elmt_type"]["initial"]()
+ self.insertcontent(index, new_element)
return new_element
else:
raise ValueError("There can't be more than %d values in \"content\"!" % maxOccurs)
@@ -1846,7 +1577,7 @@
def removeMethod(self, index):
attr_list = getattr(self, attr)
if len(attr_list) > minOccurs:
- getattr(self, attr).pop(index)
+ self.remove(attr_list[index])
else:
raise ValueError("There can't be less than %d values in \"%s\"!" % (minOccurs, attr))
return removeMethod
@@ -1857,16 +1588,112 @@
return countMethod
"""
-This function generate the classes from a class factory
+This function generate a xml parser from a class factory
"""
-def GenerateClasses(factory):
+
+NAMESPACE_PATTERN = re.compile("xmlns(?:\:[^\=]*)?=\"[^\"]*\" ")
+
+class DefaultElementClass(etree.ElementBase):
+
+ def init(self):
+ pass
+
+ def getLocalTag(self):
+ return etree.QName(self.tag).localname
+
+ def tostring(self):
+ return NAMESPACE_PATTERN.sub("", etree.tostring(self, pretty_print=True))
+
+class XMLElementClassLookUp(etree.PythonElementClassLookup):
+
+ def __init__(self, classes, *args, **kwargs):
+ etree.PythonElementClassLookup.__init__(self, *args, **kwargs)
+ self.LookUpClasses = classes
+
+ def GetElementClass(self, element_tag, parent_tag=None, default=DefaultElementClass):
+ element_class = self.LookUpClasses.get(element_tag, (default, None))
+ if not isinstance(element_class, DictType):
+ if isinstance(element_class[0], (StringType, UnicodeType)):
+ return self.GetElementClass(element_class[0], default=default)
+ return element_class[0]
+
+ element_with_parent_class = element_class.get(parent_tag, default)
+ if isinstance(element_with_parent_class, (StringType, UnicodeType)):
+ return self.GetElementClass(element_with_parent_class, default=default)
+ return element_with_parent_class
+
+ def lookup(self, document, element):
+ parent = element.getparent()
+ return self.GetElementClass(element.tag,
+ parent.tag if parent is not None else None)
+
+class XMLClassParser(etree.XMLParser):
+
+ def __init__(self, namespaces, default_namespace_format, base_class, *args, **kwargs):
+ etree.XMLParser.__init__(self, *args, **kwargs)
+ self.DefaultNamespaceFormat = default_namespace_format
+ self.NSMAP = namespaces
+ targetNamespace = etree.QName(default_namespace_format % "d").namespace
+ if targetNamespace is not None:
+ self.RootNSMAP = {
+ name if targetNamespace != uri else None: uri
+ for name, uri in namespaces.iteritems()}
+ else:
+ self.RootNSMAP = namespaces
+ self.BaseClass = base_class
+
+ def set_element_class_lookup(self, class_lookup):
+ etree.XMLParser.set_element_class_lookup(self, class_lookup)
+ self.ClassLookup = class_lookup
+
+ def Dumps(self, xml_obj):
+ return etree.tostring(xml_obj)
+
+ def Loads(self, xml_string):
+ return etree.fromstring(xml_string, self)
+
+ def CreateRoot(self):
+ if self.BaseClass is not None:
+ root = self.makeelement(
+ self.DefaultNamespaceFormat % self.BaseClass[0],
+ nsmap=self.RootNSMAP)
+ root.init()
+ return root
+ return None
+
+ def GetElementClass(self, element_tag, parent_tag=None):
+ return self.ClassLookup.GetElementClass(
+ self.DefaultNamespaceFormat % element_tag,
+ self.DefaultNamespaceFormat % parent_tag
+ if parent_tag is not None else parent_tag,
+ None)
+
+ def CreateElement(self, element_tag, parent_tag=None):
+ new_element = self.GetElementClass(element_tag, parent_tag)()
+ DefaultElementClass.__setattr__(new_element, "tag", self.DefaultNamespaceFormat % element_tag)
+ new_element.init()
+ return new_element
+
+def GenerateParser(factory, xsdstring):
ComputedClasses = factory.CreateClasses()
if factory.FileName is not None and len(ComputedClasses) == 1:
- UpdateXMLClassGlobals(ComputedClasses[factory.FileName])
- return ComputedClasses[factory.FileName]
+ ComputedClasses = ComputedClasses[factory.FileName]
+ BaseClass = [(name, XSDclass) for name, XSDclass in ComputedClasses.items() if XSDclass.IsBaseClass]
else:
- UpdateXMLClassGlobals(ComputedClasses)
- return ComputedClasses
+ BaseClass = []
+ UpdateXMLClassGlobals(ComputedClasses)
+
+ parser = XMLClassParser(
+ factory.NSMAP,
+ factory.etreeNamespaceFormat,
+ BaseClass[0] if len(BaseClass) == 1 else None,
+ schema = etree.XMLSchema(etree.fromstring(xsdstring)),
+ strip_cdata = False, remove_blank_text=True)
+ class_lookup = XMLElementClassLookUp(factory.ComputedClassesLookUp)
+ parser.set_element_class_lookup(class_lookup)
+
+ return parser
def UpdateXMLClassGlobals(classes):
globals().update(classes)
+
--- a/xmlclass/xsdschema.py Wed Sep 04 00:06:44 2013 +0200
+++ b/xmlclass/xsdschema.py Mon Sep 09 00:48:34 2013 +0200
@@ -939,8 +939,9 @@
factory.BlockDefault = attributes["blockDefault"]
factory.FinalDefault = attributes["finalDefault"]
- if attributes.has_key("targetNamespace"):
- factory.TargetNamespace = factory.DefinedNamespaces.get(attributes["targetNamespace"], None)
+ factory.TargetNamespace = factory.DefinedNamespaces.get(attributes["targetNamespace"], None)
+ if factory.TargetNamespace is not None:
+ factory.etreeNamespaceFormat = "{%s}%%s" % attributes["targetNamespace"]
factory.Namespaces[factory.TargetNamespace] = {}
annotations, children = factory.ReduceElements(elements, True)
@@ -1030,15 +1031,14 @@
schema = child
break
for qualified_name, attr in schema._attrs.items():
- value = GetAttributeValue(attr)
- if value == "http://www.w3.org/2001/XMLSchema":
- namespace, name = DecomposeQualifiedName(qualified_name)
- if namespace == "xmlns":
- self.DefinedNamespaces["http://www.w3.org/2001/XMLSchema"] = name
+ namespace, name = DecomposeQualifiedName(qualified_name)
+ if namespace == "xmlns":
+ value = GetAttributeValue(attr)
+ self.DefinedNamespaces[value] = name
+ self.NSMAP[name] = value
+ if value == "http://www.w3.org/2001/XMLSchema":
self.SchemaNamespace = name
- else:
- self.DefinedNamespaces["http://www.w3.org/2001/XMLSchema"] = self.SchemaNamespace
- self.Namespaces[self.SchemaNamespace] = XSD_NAMESPACE
+ self.Namespaces[self.SchemaNamespace] = XSD_NAMESPACE
self.Schema = XSD_NAMESPACE["schema"]["extract"]["default"](self, schema)
ReduceSchema(self, self.Schema[1], self.Schema[2])
@@ -1084,19 +1084,20 @@
return None
"""
-This function opens the xsd file and generate the classes from the xml tree
+This function opens the xsd file and generate a xml parser with class lookup from
+the xml tree
"""
-def GenerateClassesFromXSD(filepath):
+def GenerateParserFromXSD(filepath):
xsdfile = open(filepath, 'r')
- factory = XSDClassFactory(minidom.parse(xsdfile), filepath)
+ xsdstring = xsdfile.read()
xsdfile.close()
- return GenerateClasses(factory)
+ return GenerateParser(XSDClassFactory(minidom.parseString(xsdstring), filepath), xsdstring)
"""
-This function generate the classes from the xsd given as a string
+This function generate a xml from the xsd given as a string
"""
-def GenerateClassesFromXSDstring(xsdstring):
- return GenerateClasses(XSDClassFactory(minidom.parseString(xsdstring)))
+def GenerateParserFromXSDstring(xsdstring):
+ return GenerateParser(XSDClassFactory(minidom.parseString(xsdstring)))
#-------------------------------------------------------------------------------