else:

tempvar.setaddress(None)

if var['Documentation'] != "":

ft.setanyText(var['Documentation'])

tempvar.setdocumentation(ft)

if project is not None:

# Found the resource corresponding to name

resource = project.getconfigurationResource(config_name, name)

# Extract variables from every varLists

for varlist in resource.getglobalVars():

for var in varlist.getvariable():

pou.interface = PLCOpenParser.CreateElement("interface", "pou")

# If there isn't any return type yet, add it

return_type_obj = pou.interface.getreturnType()

return_type_obj = PLCOpenParser.CreateElement("returnType", "interface")

pou.interface.setreturnType(return_type_obj)

# Change return type

self.Project.RefreshCustomBlockTypes()

def UpdateProjectUsedPous(self, old_name, new_name):

self.Project.updateElementName(old_name, new_name)

def UpdateEditedElementUsedVariable(self, tagname, old_name, new_name):

pou = self.GetEditedElement(tagname)

pou.updateElementName(old_name, new_name)

# Return the return type of the pou given by its name

derived_datatype.setname(infos["base_type"])

datatype.baseType.setcontent(derived_datatype)

elif infos["type"] == "Subrange":

"subrangeUnsigned"

if infos["base_type"] in GetSubTypes("ANY_UINT")

subrange.range.setlower(infos["min"])

subrange.range.setupper(infos["max"])

if infos["base_type"] in self.GetBaseTypes():

subrange.baseType.setcontent(

else:

derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")

derived_datatype.setname(infos["base_type"])

subrange.baseType.setcontent(derived_datatype)

elif infos["type"] == "Enumerated":

enumerated = PLCOpenParser.CreateElement("enum", "dataType")

values = PLCOpenParser.CreateElement("values", "enum")

enumerated.setvalues(values)

for i, enum_value in enumerate(infos["values"]):

values.setvalue([value])

else:

values.appendvalue(value)

elif infos["type"] == "Array":

array = PLCOpenParser.CreateElement("array", "dataType")

for i, dimension in enumerate(infos["dimensions"]):

dimension_range = PLCOpenParser.CreateElement("dimension", "array")

dimension_range.setlower(dimension[0])

derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")

derived_datatype.setname(infos["base_type"])

array.baseType.setcontent(derived_datatype)

elif infos["type"] == "Structure":

struct = PLCOpenParser.CreateElement("struct", "dataType")

for i, element_infos in enumerate(infos["elements"]):

element = PLCOpenParser.CreateElement("variable", "struct")

element.setname(element_infos["Name"])

if element_infos["Type"][0] == "array":

array_type, base_type_name, dimensions = element_infos["Type"]

array = PLCOpenParser.CreateElement("array", "dataType")

for j, dimension in enumerate(dimensions):

dimension_range = PLCOpenParser.CreateElement("dimension", "array")

dimension_range.setlower(dimension[0])

derived_datatype = PLCOpenParser.CreateElement("derived", "dataType")

derived_datatype.setname(base_type_name)

array.baseType.setcontent(derived_datatype)

elif element_infos["Type"] in self.GetBaseTypes():

element_type.setcontent(

PLCOpenParser.CreateElement(

struct.setvariable([element])

else:

struct.appendvariable(element)

if infos["initial"] != "":

if datatype.initialValue is None:

datatype.initialValue = PLCOpenParser.CreateElement("initialValue", "dataType")

variable.text = value

contact.setvariable(variable)

elif param == "type":

elif param == "height":

contact.setheight(value)

elif param == "width":

variable.text = value

coil.setvariable(variable)

elif param == "type":

elif param == "height":

coil.setheight(value)

elif param == "width":

resource.setpouInstance([])

task_list = {}

for task in tasks:

new_task.setname(task["Name"])

if task["Triggering"] == "Interrupt":

new_task.setsingle(task["Single"])

new_task.setpriority(int(task["Priority"]))

if task["Name"] != "":

task_list[task["Name"]] = new_task

for instance in instances:

new_instance.setname(instance["Name"])

new_instance.settypeName(instance["Type"])

def GetEditedResourceInfos(self, tagname, debug = False):

resource = self.GetEditedElement(tagname, debug)

def LoadProject(filepath):

project_file = open(filepath)

project_file.close()

return etree.fromstring(project_xml, PLCOpenParser)

cls = PLCOpenParser.GetElementClass("formattedText")

if cls:

def updateElementName(self, old_name, new_name):

index = text.find(old_name)

while index != -1:

if index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_"):

else:

text = text[:index] + new_name + text[index + len(old_name):]

index = text.find(old_name, index + len(new_name))

setattr(cls, "updateElementName", updateElementName)

def updateElementAddress(self, address_model, new_leading):

startpos = 0

result = address_model.search(text, startpos)

while result is not None:

text = text[:result.start()] + new_address + text[result.end():]

startpos = result.start() + len(new_address)

result = address_model.search(self.text, startpos)

setattr(cls, "updateElementAddress", updateElementAddress)

def hasblock(self, block_type):

index = text.find(block_type.upper())

while index != -1:

if (not (index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_")) and

def getconfigurations(self):

configurations = self.instances.configurations.getconfiguration()

return configurations

return []

setattr(cls, "getconfigurations", getconfigurations)

def getconfigurationResource(self, config_name, name):

configuration = self.getconfiguration(config_name)

for resource in configuration.getresource():

if resource.getname() == name:

return resource

def addconfigurationResource(self, config_name, name):

configuration = self.getconfiguration(config_name)

for resource in configuration.getresource():

if resource.getname() == name:

raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name)

def removeconfigurationResource(self, config_name, name):

configuration = self.getconfiguration(config_name)

found = False

for idx, resource in enumerate(configuration.getresource()):

if resource.getname() == name:

self.CustomDataTypeRange[name] = range

base_type = basetype_content.baseType.getcontent()

if base_type.__class__ == DefaultElementClass:

else:

self.CustomTypeHierarchy[name] = base_type.getname()

else:

if location != "":

var.setaddress(location)

if description != "":

ft.setanyText(description)

var.setdocumentation(ft)

globalvars[-1].appendvariable(var)

new_datatype = PLCOpenParser.CreateElement("dataType", "dataTypes")

self.dataTypes.appenddataType(new_datatype)

new_datatype.setname(name)

setattr(cls, "appenddataTypeElement", appenddataTypeElement)

def insertdataTypeElement(self, index, dataType):

search_result = []

content_name = self.content.getLocalTag()

if content_name in ["derived", "array", "enum", "subrangeSigned", "subrangeUnsigned"]:

elif content_name == "struct":

search_result.extend(element.Search(criteria, parent_infos + ["struct", i]))

else:

if content_name in ["string", "wstring"]:

return search_result

setattr(cls, "Search", Search)

cls = PLCOpenParser.GetElementClass("array", "dataType")

if cls:

setattr(cls, "updateElementName", _updateBaseTypeElementName)

def Search(self, criteria, parent_infos=[]):

search_result = []

for result in TestTextElement(value.getname(), criteria):

search_result.append((tuple(parent_infos + ["value", i]),) + result)

return search_result

def setdescription(self, description):

doc = self.getdocumentation()

if doc is None:

self.setdocumentation(doc)

doc.setanyText(description)

setattr(cls, "setdescription", setdescription)

if self.interface is None:

self.interface = PLCOpenParser.CreateElement("interface", "pou")

content = self.interface.getcontent()

else:

variables = varlist.getvariable()

if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress():

var = PLCOpenParser.CreateElement("variable", "varListPlain")

var.setname(name)

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"]

if location != "":

var.setaddress(location)

if description != "":

ft.setanyText(description)

var.setdocumentation(ft)

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:

for var in variables:

if var.getname() == old_name:

vartype_content = var.gettype().getcontent()

setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder)

def setelementExecutionOrder(self, instance, new_executionOrder):

old_executionOrder = instance.getexecutionOrderId()

if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0:

for element in self.content.getcontent():

_getexecutionOrder(self, specific_values)

specific_values["negated"] = self.getnegated()

specific_values["edge"] = self.getedge()

specific_values["storage"] = self.getstorage()

infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True))

infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))

condition = self.getconditionContent()

specific_values["condition_type"] = condition["type"]

if specific_values["condition_type"] == "connection":

else:

infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True))

infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))

return infos

def GenerateAnyInfos(infos):

if infos["namespace"][0] == "##any":

def GenerateAny(tree, value):

def InitialAny():

if infos["namespace"][0] == "##any":

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 elements.has_key(name):

element_infos = elements[name]

self.remove(element)

if value is not None:

if not isinstance(value, ListType):

value = [value]