beremiz: comparison PLCGenerator.py

equal deleted inserted replaced

-:5f8e02717560
+:cd639725fba5
 #
 #You should have received a copy of the GNU General Public
 #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
 # Dictionary associating PLCOpen variable categories to the corresponding
 tagname = self.Controler.ComputeDataTypeName(datatype.getname())
 datatype_def = [("  ", ()),
 (datatype.getname(), (tagname, "name")),
 (" : ", ())]
 basetype_content = datatype.baseType.getcontent()
-# Data type derived directly from a string type
+basetype_content_type = basetype_content.getLocalTag()
-if basetype_content["name"] in ["string", "wstring"]:
-datatype_def += [(basetype_content["name"].upper(), (tagname, "base"))]
 # Data type derived directly from a user defined type
-elif basetype_content["name"] == "derived":
+if basetype_content_type == "derived":
-basetype_name = basetype_content["value"].getname()
+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"]:
+elif basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
-base_type = basetype_content["value"].baseType.getcontent()
+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":
+if base_type_type == "derived":
-basetype_name = base_type["value"].getname()
+basetype_name = base_type_type.getname()
 self.GenerateDataType(basetype_name)
 # Subrange derived directly from an elementary type
 else:
-basetype_name = base_type["name"]
+basetype_name = base_type_type
-min_value = basetype_content["value"].range.getlower()
+min_value = basetype_content.range.getlower()
-max_value = basetype_content["value"].range.getupper()
+max_value = basetype_content.range.getupper()
 datatype_def += [(basetype_name, (tagname, "base")),
 (" (", ()),
 ("%s"%min_value, (tagname, "lower")),
 ("..", ()),
 ("%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":
+elif basetype_content_type == "array":
-base_type = basetype_content["value"].baseType.getcontent()
+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":
+if base_type_type == "derived":
-basetype_name = base_type["value"].getname()
+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":
+if element_type_type == "derived":
-elementtype_name = element_type["value"].getname()
+elementtype_name = element_type.getname()
 self.GenerateDataType(elementtype_name)
-elif element_type["name"] == "array":
+elif element_type_type == "array":
-base_type = element_type["value"].baseType.getcontent()
+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":
+if base_type_type == "derived":
-basetype_name = base_type["value"].getname()
+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")),
 (" : ", ()),
 (elementtype_name, (tagname, "struct", i, "type"))]
 if element.initialValue is not None:
 datatype_def += [("STRUCT", ())]
 datatype_def += JoinList([("", ())], elements)
 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 += [(" := ", ()),
 (self.ComputeValue(datatype.initialValue.getvalue(), datatype_name), (tagname, "initial value"))]
 datatype_def += [(";\n", ())]
 varlists = [(varlist, varlist.getvariable()[:]) for varlist in configuration.getglobalVars()]
 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
 for varlist, varlist_variables in varlists:
 variable_type = errorVarTypes.get("VAR_GLOBAL", "var_local")
 config += [(" NON_RETAIN", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "non_retain"))]
 config += [("\n", ())]
 # Generate any variable of this block
 for var in varlist_variables:
 vartype_content = var.gettype().getcontent()
-if vartype_content["name"] == "derived":
+if vartype_content.getLocalTag() == "derived":
-var_type = vartype_content["value"].getname()
+var_type = vartype_content.getname()
 self.GenerateDataType(var_type)
 else:
 var_type = var.gettypeAsText()
 config += [("    ", ()),
 resrce += [(" NON_RETAIN", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "non_retain"))]
 resrce += [("\n", ())]
 # Generate any variable of this block
 for var in varlist.getvariable():
 vartype_content = var.gettype().getcontent()
-if vartype_content["name"] == "derived":
+if vartype_content.getLocalTag() == "derived":
-var_type = vartype_content["value"].getname()
+var_type = vartype_content.getname()
 self.GenerateDataType(var_type)
 else:
 var_type = var.gettypeAsText()
 resrce += [("      ", ()),
 #-------------------------------------------------------------------------------
 #                           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:
 # Create a new POU program generator
 def __init__(self, parent, name, type, errors, warnings):
 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
 elif parameter:
 for variable in outputvariables:
 for variable in outputvariables:
 relposition = variable.connectionPointOut.getrelPositionXY()
 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]
 else:
 point = link.getposition()[-1]
 if interface is not None:
 body = pou.getbody()
 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":
+returntype_content_type = returntype_content.getLocalTag()
-self.ReturnType = returntype_content["value"].getname()
+if returntype_content_type == "derived":
-elif returntype_content["name"] in ["string", "wstring"]:
+self.ReturnType = returntype_content.getname()
-self.ReturnType = returntype_content["name"].upper()
+else:
-else:
+self.ReturnType = returntype_content_type.upper()
-self.ReturnType = returntype_content["name"]
 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":
+if vartype_content.getLocalTag() == "derived":
-var_type = vartype_content["value"].getname()
+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
 for variable in blocktype["initialise"](var_type, var.getname(), block):
 if variable[2] is not None:
 initial_value = initial.getvalue()
 else:
 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()
 if initial:
 initial_value = initial.getvalue()
 address = var.getaddress()
 if address is not None:
 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",
 "D": "DATE",
 "TOD": "TIME_OF_DAY",
 def ComputeConnectionTypes(self, pou):
 body = pou.getbody()
 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)):
+if isinstance(instance, (InVariableClass, OutVariableClass,
-expression = instance.getexpression()
+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":
+returntype_content_type = returntype_content.getLocalTag()
-var_type = returntype_content["value"].getname()
+if returntype_content_type == "derived":
-elif returntype_content["name"] in ["string", "wstring"]:
+var_type = returntype_content.getname()
-var_type = returntype_content["name"].upper()
 else:
-var_type = returntype_content["name"]
+var_type = returntype_content_type.upper()
 elif var_type is None:
 parts = expression.split("#")
 if len(parts) > 1:
 literal_prefix = parts[0].upper()
 var_type = self.LITERAL_TYPES.get(literal_prefix,
 elif expression.startswith("'"):
 var_type = "STRING"
 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)):
+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):
+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):
+elif isinstance(instance, TransitionClass):
-content = instance.condition.getcontent()
+content = instance.getconditionContent()
-if content["name"] == "connection" and len(content["value"]) == 1:
+if content["type"] == "connection":
-connected = self.GetLinkedConnector(content["value"][0], body)
+connected = self.GetLinkedConnector(content["value"], 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):
+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]
 else:
 for connection in related:
 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)
 else:
 for variable in instance.inputVariables.getvariable():
 def ComputeProgram(self, pou):
 body = pou.getbody()
 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, JumpClass):
 self.GenerateSFCJump(instance, pou)
 if len(self.InitialSteps) > 0 and len(self.SFCComputedBlocks) > 0:
 action_name = "COMPUTE_FUNCTION_BLOCKS"
 action_infos = {"qualifier" : "S", "content" : action_name}
 self.SFCNetworks["Steps"][self.InitialSteps[0]]["actions"].append(action_infos)
 self.ComputeSFCStep(initialstep)
 else:
 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)
 otherInstances["blocks"].sort(SortInstances)
 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"]))
 if block_infos is None:
 block_infos = self.GetBlockType(block_type)
 raise PLCGenException, _("Undefined block type \"%s\" in \"%s\" POU")%(block_type, self.Name)
 try:
 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())
 expression = self.ComputeExpression(body, connections)
 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):
 same_paths = {}
 uncomputed_index = range(len(paths))
 def GeneratePaths(self, connections, body, order = False, to_inout = False):
 paths = []
 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)):
+elif isinstance(next, (InVariableClass, InOutVariableClass)):
-paths.append(str([(next.getexpression(), (self.TagName, "io_variable", localId, "expression"))]))
+paths.append(str([(next.getexpression().text, (self.TagName, "io_variable", localId, "expression"))]))
-elif isinstance(next, plcopen.fbdObjects_block):
+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"]))
 if block_infos is None:
 block_infos = self.GetBlockType(block_type)
 raise PLCGenException, _("Undefined block type \"%s\" in \"%s\" POU")%(block_type, self.Name)
 try:
 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:
 paths.append(str(computed_value))
 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
 if connector is not None:
 connections = connector.connectionPointIn.getconnections()
 if expression is not None:
 self.ComputedConnectors[name] = expression
 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)
 if len(factorized_paths) > 1:
 paths.append([variable, tuple(factorized_paths)])
 paths.append([variable] + result[0])
 elif result[0] is not None:
 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
 def ComputePaths(self, paths, first = False):
 if type(paths) == TupleType:
 instanceLocalId = connections[0].getrefLocalId()
 body = pou.getbody()
 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 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)
 if instance in self.SFCNetworks["Transitions"].keys():
 target_info = (self.TagName, "transition", instance.getlocalId(), "to", step_infos["id"])
 instanceLocalId = connections[0].getrefLocalId()
 body = pou.getbody()
 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 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)
 if instance in self.SFCNetworks["Transitions"].keys():
 target_info = (self.TagName, "jump", jump.getlocalId(), "target")
 instanceLocalId = connections[0].getrefLocalId()
 body = pou.getbody()
 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 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" : []}
 transitionBody = transitionContent.getbody()
 previous_tagname = self.TagName
 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"]\
+if isinstance(instance, OutVariableClass) and instance.getexpression().text == transitionValues["value"]\
-or isinstance(instance, plcopen.ldObjects_coil) and instance.getvariable() == 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)
 if expression is not None:
 transition_infos["content"] = [("\n%s:= "%self.CurrentIndent, ())] + expression + [(";\n", ())]

changeset 1297	cd639725fba5
parent 1239	d1f6ea56555d
child 1298	f034fb2b1aab