# HG changeset patch # User Laurent Bessard # Date 1378680514 -7200 # Node ID 26e8b99bc2c3d1dbc07dfd769969333eb4bbfe5d # Parent 1d221eda1e42c88fbeff747cbcdf959f0845d10a# Parent 1ff1cdf6c3183d52b631c4bcd13f61b50cfee1c4 Merged diff -r 1d221eda1e42 -r 26e8b99bc2c3 IDEFrame.py --- 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): diff -r 1d221eda1e42 -r 26e8b99bc2c3 PLCControler.py --- 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 = "%s"%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 = "\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: diff -r 1d221eda1e42 -r 26e8b99bc2c3 PLCGenerator.py --- 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, ())] diff -r 1d221eda1e42 -r 26e8b99bc2c3 PLCOpenEditor.py --- 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) diff -r 1d221eda1e42 -r 26e8b99bc2c3 editors/Viewer.py --- 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: diff -r 1d221eda1e42 -r 26e8b99bc2c3 plcopen/__init__.py --- 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 * diff -r 1d221eda1e42 -r 26e8b99bc2c3 plcopen/plcopen.py --- 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 = """ + + + + + + + + + + + + %s + + + + + +""" + +def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type): + return LOAD_POU_PROJECT_TEMPLATE % """ + + + <%(body_type)s>%%s + +""" % 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("(?)(?:)(?!)"), "]]>")]: + 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) + diff -r 1d221eda1e42 -r 26e8b99bc2c3 plcopen/structures.py --- 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 diff -r 1d221eda1e42 -r 26e8b99bc2c3 xmlclass/__init__.py --- 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 diff -r 1d221eda1e42 -r 26e8b99bc2c3 xmlclass/xmlclass.py --- 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'\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'\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) + diff -r 1d221eda1e42 -r 26e8b99bc2c3 xmlclass/xsdschema.py --- 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))) #-------------------------------------------------------------------------------