diff -r 635d0817508c -r 394d9f168258 plcopen/plcopen.py --- a/plcopen/plcopen.py Tue Nov 27 12:58:34 2007 +0100 +++ b/plcopen/plcopen.py Thu Dec 06 18:05:29 2007 +0100 @@ -46,39 +46,6 @@ PLCOpenClasses, PLCOpenTypes = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd")) -cls = PLCOpenClasses.get("dataType", None) -if cls: - cls.value = None - - def getValue(self): - return self.value - setattr(cls, "getValue", getValue) - - def setValue(self, value): - self.value = value - setattr(cls, "setValue", setValue) - - def loadXMLTree(self, tree): - node = tree.childNodes[1] - if node.nodeName == "derived": - self.value = PLCOpenClasses["derived"]() - self.value.loadXMLTree(node) - else: - self.value = node.nodeName - setattr(cls, "loadXMLTree", loadXMLTree) - - def generateXMLText(self, name, indent, extras = {}): - ind1, ind2 = getIndent(indent, name) - text = ind1 + "<%s>\n"%name - if isinstance(self.value, (StringType, UnicodeType)): - ind3, ind4 = getIndent(indent + 1, self.value) - text += ind3 + "<%s/>\n"%self.value - else: - text += self.value.generateXMLText("derived", indent + 1) - text += ind1 + "\n"%name - return text - setattr(cls, "generateXMLText", generateXMLText) - cls = PLCOpenClasses.get("formattedText", None) if cls: cls.text = "" @@ -159,6 +126,26 @@ def getName(self): return self.contentHeader.getName() setattr(cls, "getName", getName) + + def getDataTypes(self): + return self.types.getDataTypeElements() + setattr(cls, "getDataTypes", getDataTypes) + + def getDataType(self, name): + return self.types.getDataTypeElement(name) + setattr(cls, "getDataType", getDataType) + + def appendDataType(self, name): + self.types.appendDataTypeElement(name) + setattr(cls, "appendDataType", appendDataType) + + def insertDataType(self, index, datatype): + self.types.insertDataTypeElement(index, datatype) + setattr(cls, "insertDataType", insertDataType) + + def removeDataType(self, name): + self.types.removeDataTypeElement(name) + setattr(cls, "removeDataType", removeDataType) def getPous(self): return self.types.getPouElements() @@ -293,6 +280,43 @@ cls = PLCOpenClasses.get("project_types", None) if cls: + def getDataTypeElements(self): + return self.dataTypes.getDataType() + setattr(cls, "getDataTypeElements", getDataTypeElements) + + def getDataTypeElement(self, name): + elements = self.dataTypes.getDataType() + for element in elements: + if element.getName() == name: + return element + return None + setattr(cls, "getDataTypeElement", getDataTypeElement) + + def appendDataTypeElement(self, name): + for element in self.dataTypes.getDataType(): + if element.getName() == name: + raise ValueError, "\"%s\" Data Type already exists !!!"%name + new_datatype = PLCOpenClasses["dataTypes_dataType"]() + new_datatype.setName(name) + new_datatype.baseType.setContent("BOOL", None) + self.dataTypes.appendDataType(new_datatype) + setattr(cls, "appendDataTypeElement", appendDataTypeElement) + + def insertDataTypeElement(self, index, datatype): + self.dataTypes.insertDataType(index, datatype) + setattr(cls, "insertDataTypeElement", insertDataTypeElement) + + def removeDataTypeElement(self, name): + found = False + for idx, element in enumerate(self.dataTypes.getDataType()): + if element.getName() == name: + self.dataTypes.removeDataType(idx) + found = True + break + if not found: + raise ValueError, "\"%s\" Data Type doesn't exist !!!"%name + setattr(cls, "removeDataTypeElement", removeDataTypeElement) + def getPouElements(self): return self.pous.getPou() setattr(cls, "getPouElements", getPouElements) @@ -440,10 +464,10 @@ variables = varlist["value"].getVariable() for var in variables: if var.getName() == old_name: - var_type = var.getType().getValue() - if isinstance(var_type, PLCOpenClasses["derived"]) and var_type.getName() == old_type: + vartype_content = var.getType().getContent() + if vartype_content["value"] is not None and vartype_content["value"].getName() == old_type: var.setName(new_name) - var.getType().getValue().setName(new_type) + vartype_content["value"].setName(new_type) return setattr(cls, "changePouVar", changePouVar) @@ -1415,61 +1439,71 @@ cls = PLCOpenClasses.get("value", None) if cls: def setValue(self, value): - try: - value = eval(value) - except: - pass - if type(value) == ListType: + if value.startswith("[") and value.endswith("]"): arrayValue = PLCOpenClasses["value_arrayValue"]() - arrayValue.setValue(value) self.content = {"name":"arrayValue","value":arrayValue} - elif type(value) == DictType: + elif value.startswith("(") and value.endswith(")"): structValue = PLCOpenClasses["value_structValue"]() - structValue.setValue(value) self.content = {"name":"structValue","value":structValue} else: simpleValue = PLCOpenClasses["value_simpleValue"]() - simpleValue.setValue(str(value)) self.content = {"name":"simpleValue","value":simpleValue} + self.content["value"].setValue(value) setattr(cls, "setValue", setValue) def getValue(self): - value = self.content["value"].getValue() - try: - value = eval(value) - except: - pass - return value + return self.content["value"].getValue() setattr(cls, "getValue", getValue) cls = PLCOpenClasses.get("value_arrayValue", None) if cls: - def setValue(self, array): + arrayValue_model = re.compile("([0-9]*)\((.*)\)") + + def setValue(self, value): self.value = [] - for value in array: + for item in value[1:-1].split(","): + item = item.strip() element = PLCOpenClasses["arrayValue_value"]() - element.setValue(value) + result = arrayValue_model.match(item) + if result is not None: + groups = result.groups() + element.setRepetitionValue(int(groups[0])) + element.setValue(groups[1].strip()) + else: + element.setValue(item) self.value.append(element) setattr(cls, "setValue", setValue) def getValue(self): - return [element.getValue() for element in self.value] + values = [] + for element in self.value: + repetition = element.getRepetitionValue() + if repetition is not None and repetition > 1: + values.append("%d(%s)"%(repetition, element.getValue())) + else: + values.append(element.getValue()) + return "[%s]"%", ".join(values) setattr(cls, "getValue", getValue) cls = PLCOpenClasses.get("value_structValue", None) if cls: - def setValue(self, dict): + structValue_model = re.compile("(.*):=(.*)") + + def setValue(self, value): self.value = [] - for name,value in dict.items(): - element = PLCOpenClasses["structValue_value"]() - element.setMember(name) - element.setValue(value) + for item in value[1:-1].split(","): + result = arrayValue_model.match(item) + if result is not None: + groups = result.groups() + element = PLCOpenClasses["structValue_value"]() + element.setMember(groups[0].strip()) + element.setValue(groups[1].strip()) self.value.append(element) setattr(cls, "setValue", setValue) def getValue(self): - value = {} + values = [] for element in self.value: - value[element.getMember()] = element.getValue() - return value + values.append("%s := %s"%(element.getMember(), element.getValue())) + return "(%s)"%", ".join(values) setattr(cls, "getValue", getValue)