beremiz: comparison PLCGenerator.py

equal deleted inserted replaced

-:dea107dce0c4
+:750eeb7230a1
 indent = ""
 for i in xrange(spaces, nb_spaces):
 indent += " "
 for line in lines:
 if line != "":
-compute += "%s%s\n"%(indent, line)
+compute += "%s%s\n" % (indent, line)
 else:
 compute += "\n"
 return compute
 def SortInstances(a, b):
 # Compute value according to type given
 def ComputeValue(self, value, var_type):
 base_type = self.Controler.GetBaseType(var_type)
 if base_type == "STRING" and not value.startswith("'") and not value.endswith("'"):
-return "'%s'"%value
+return "'%s'" % value
 elif base_type == "WSTRING" and not value.startswith('"') and not value.endswith('"'):
-return "\"%s\""%value
+return "\"%s\"" % value
 return value
 # Generate a data type from its name
 def GenerateDataType(self, datatype_name):
 # Verify that data type hasn't been generated yet
 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")),
+("%s" % min_value, (tagname, "lower")),
 ("..", ()),
-("%s"%max_value, (tagname, "upper")),
+("%s" % max_value, (tagname, "upper")),
 (")",())]
 # Data type is an enumerated type
 elif basetype_content_type == "enum":
 values = [[(value.getname(), (tagname, "value", i))]
 for i, value in enumerate(
 basetype_name = base_type.getname()
 self.GenerateDataType(basetype_name)
 # Array derived directly from an elementary type
 else:
 basetype_name = base_type_type.upper()
-dimensions = [[("%s"%dimension.getlower(), (tagname, "range", i, "lower")),
+dimensions = [[("%s" % dimension.getlower(), (tagname, "range", i, "lower")),
 ("..", ()),
-("%s"%dimension.getupper(), (tagname, "range", i, "upper"))]
+("%s" % dimension.getupper(), (tagname, "range", i, "upper"))]
 for i, dimension in enumerate(basetype_content.getdimension())]
 datatype_def += [("ARRAY [", ())]
 datatype_def += JoinList([(",", ())], dimensions)
 datatype_def += [("] OF " , ()),
 (basetype_name, (tagname, "base"))]
 # Create a POU program generator
 pou_program = PouProgramGenerator(self, pou.getname(), pouTypeNames[pou_type], self.Errors, self.Warnings)
 program = pou_program.GenerateProgram(pou)
 self.Program += program
 else:
-raise PLCGenException, _("Undefined pou type \"%s\"")%pou_type
+raise PLCGenException, _("Undefined pou type \"%s\"") % pou_type
 # Generate a POU defined and used in text
 def GeneratePouProgramInText(self, text):
 for pou_name in self.PouComputed.keys():
-model = re.compile("(?:^|[^0-9^A-Z])%s(?:$|[^0-9^A-Z])"%pou_name.upper())
+model = re.compile("(?:^|[^0-9^A-Z])%s(?:$|[^0-9^A-Z])" % pou_name.upper())
 if model.search(text) is not None:
 self.GeneratePouProgram(pou_name)
 # Generate a configuration from its model
 def GenerateConfiguration(self, configuration):
 ##                if interval.microsecond != 0:
 ##                    resrce += [("%dms"%(interval.microsecond / 1000), (tagname, "task", task_number, "interval", "millisecond"))]
 ##                resrce += [(",", ())]
 # Priority argument
 resrce += [("PRIORITY := ", ()),
-("%d"%task.getpriority(), (tagname, "task", task_number, "priority")),
+("%d" % task.getpriority(), (tagname, "task", task_number, "priority")),
 (");\n", ())]
 task_number += 1
 instance_number = 0
 # Generate any program assign to each task
 for task in tasks:
 for instance in undefined_blocks:
 block_infos = self.GetBlockType(instance.gettypeName(), tuple([self.ConnectionTypes.get(variable.connectionPointIn, "ANY") for variable in instance.inputVariables.getvariable() if variable.getformalParameter() != "EN"]))
 if block_infos is not None:
 self.ComputeBlockInputTypes(instance, block_infos, body)
 else:
-raise PLCGenException, _("No informations found for \"%s\" block")%(instance.gettypeName())
+raise PLCGenException, _("No informations found for \"%s\" block") % (instance.gettypeName())
 if body_type == "SFC":
 previous_tagname = self.TagName
 for action in pou.getactionList():
 self.TagName = self.ParentGenerator.Controler.ComputePouActionName(self.Name, action.getname())
 self.ComputeConnectionTypes(action)
 if one_input_connected:
 for i, variable in enumerate(output_variables):
 parameter = variable.getformalParameter()
 if not inout_variables.has_key(parameter) and parameter in output_names + ["", "ENO"]:
 if variable.getformalParameter() == "":
-variable_name = "%s%d"%(type, block.getlocalId())
+variable_name = "%s%d" % (type, block.getlocalId())
 else:
-variable_name = "%s%d_%s"%(type, block.getlocalId(), parameter)
+variable_name = "%s%d_%s" % (type, block.getlocalId(), parameter)
 if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:
 self.Interface.append(("VAR", None, False, []))
 if variable.connectionPointOut in self.ConnectionTypes:
 self.Interface[-1][3].append((self.ConnectionTypes[variable.connectionPointOut], variable_name, None, None))
 else:
 self.Interface[-1][3].append(("ANY", variable_name, None, None))
 if len(output_variables) > 1 and parameter not in ["", "OUT"]:
 vars.append([(parameter, (self.TagName, "block", block.getlocalId(), "output", i)),
-(" => %s"%variable_name, ())])
+(" => %s" % variable_name, ())])
 else:
 output_info = (self.TagName, "block", block.getlocalId(), "output", i)
 output_name = variable_name
 self.Program += [(self.CurrentIndent, ()),
 (output_name, output_info),
 output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx)
 if inout_variables.has_key(output_parameter):
 output_value = inout_variables[output_parameter]
 else:
 if output_parameter == "":
-output_name = "%s%d"%(type, block.getlocalId())
+output_name = "%s%d" % (type, block.getlocalId())
 else:
-output_name = "%s%d_%s"%(type, block.getlocalId(), output_parameter)
+output_name = "%s%d_%s" % (type, block.getlocalId(), output_parameter)
 output_value = [(output_name, output_info)]
 return self.ExtractModifier(output_variable, output_value, output_info)
 if block_infos["type"] == "functionBlock":
 output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx)
-output_name = self.ExtractModifier(output_variable, [("%s.%s"%(name, output_parameter), output_info)], output_info)
+output_name = self.ExtractModifier(output_variable, [("%s.%s" % (name, output_parameter), output_info)], output_info)
 if to_inout:
-variable_name = "%s_%s"%(name, output_parameter)
+variable_name = "%s_%s" % (name, output_parameter)
 if not self.IsAlreadyDefined(variable_name):
 if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:
 self.Interface.append(("VAR", None, False, []))
 if variable.connectionPointOut in self.ConnectionTypes:
 self.Interface[-1][3].append(
 (self.ConnectionTypes[output_variable.connectionPointOut], variable_name, None, None))
 else:
 self.Interface[-1][3].append(("ANY", variable_name, None, None))
 self.Program += [(self.CurrentIndent, ()),
-("%s := "%variable_name, ())]
+("%s := " % variable_name, ())]
 self.Program += output_name
 self.Program += [(";\n", ())]
 return [(variable_name, ())]
 return output_name
 if link is not None:
 def AddTrigger(self, edge, expression, var_info):
 if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:
 self.Interface.append(("VAR", None, False, []))
 i = 1
-name = "%s%d"%(edge, i)
+name = "%s%d" % (edge, i)
 while self.IsAlreadyDefined(name):
 i += 1
-name = "%s%d"%(edge, i)
+name = "%s%d" % (edge, i)
 self.Interface[-1][3].append((edge, name, None, None))
 self.Program += [(self.CurrentIndent, ()), (name, var_info), ("(CLK := ", ())]
 self.Program += expression
 self.Program += [(");\n", ())]
-return [("%s.Q"%name, var_info)]
+return [("%s.Q" % name, var_info)]
 def ExtractDivergenceInput(self, divergence, pou):
 connectionPointIn = divergence.getconnectionPointIn()
 if connectionPointIn is not None:
 connections = connectionPointIn.getconnections()
 if "indicator" in action:
 action_infos["indicator"] = action["indicator"]
 if action["type"] == "reference":
 self.GenerateSFCAction(action["value"], pou)
 else:
-action_name = "%s_INLINE%d"%(step_name.upper(), self.GetActionNumber())
+action_name = "%s_INLINE%d" % (step_name.upper(), self.GetActionNumber())
 self.SFCNetworks["Actions"][action_name] = ([(self.CurrentIndent, ()),
 (action["value"], (self.TagName, "action_block", action_infos["id"], "action", i, "inline")),
 ("\n", ())], ())
 action_infos["content"] = action_name
 self.SFCNetworks["Steps"][step_name]["actions"].append(action_infos)
 "to" : [],
 "content": []}
 self.SFCNetworks["Transitions"][transition] = transition_infos
 transitionValues = transition.getconditionContent()
 if transitionValues["type"] == "inline":
-transition_infos["content"] = [("\n%s:= "%self.CurrentIndent, ()),
+transition_infos["content"] = [("\n%s:= " % self.CurrentIndent, ()),
 (transitionValues["value"], (self.TagName, "transition", transition.getlocalId(), "inline")),
 (";\n", ())]
 elif transitionValues["type"] == "reference":
 transitionContent = pou.gettransition(transitionValues["value"])
 transitionType = transitionContent.getbodyType()
 or isinstance(instance, CoilClass) and instance.getvariable() == 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", ())]
+transition_infos["content"] = [("\n%s:= " % self.CurrentIndent, ())] + expression + [(";\n", ())]
 self.SFCComputedBlocks += self.Program
 self.Program = []
 if not transition_infos.has_key("content"):
 raise PLCGenException, _("Transition \"%s\" body must contain an output variable or coil referring to its name") % transitionValues["value"]
 self.TagName = previous_tagname
 body = body[0]
 connections = transitionValues["value"].getconnections()
 if connections is not None:
 expression = self.ComputeExpression(body, connections)
 if expression is not None:
-transition_infos["content"] = [("\n%s:= "%self.CurrentIndent, ())] + expression + [(";\n", ())]
+transition_infos["content"] = [("\n%s:= " % self.CurrentIndent, ())] + expression + [(";\n", ())]
 self.SFCComputedBlocks += self.Program
 self.Program = []
 for step in steps:
 self.GenerateSFCStep(step, pou)
 step_name = step.getname()
 if "indicator" in action_infos:
 self.Program += [(", ", ()),
 (action_infos["indicator"], action_info + ("indicator",))]
 self.Program += [(");\n", ())]
 self.IndentLeft()
-self.Program += [("%sEND_STEP\n\n"%self.CurrentIndent, ())]
+self.Program += [("%sEND_STEP\n\n" % self.CurrentIndent, ())]
 for action in actions:
 self.ComputeSFCAction(action)
 for transition in step_infos["transitions"]:
 self.ComputeSFCTransition(transition)
 def ComputeSFCAction(self, action_name):
 if action_name in self.SFCNetworks["Actions"].keys():
 action_content, action_info = self.SFCNetworks["Actions"].pop(action_name)
-self.Program += [("%sACTION "%self.CurrentIndent, ()),
+self.Program += [("%sACTION " % self.CurrentIndent, ()),
 (action_name, action_info),
 (":\n", ())]
 self.Program += action_content
-self.Program += [("%sEND_ACTION\n\n"%self.CurrentIndent, ())]
+self.Program += [("%sEND_ACTION\n\n" % self.CurrentIndent, ())]
 def ComputeSFCTransition(self, transition):
 if transition in self.SFCNetworks["Transitions"].keys():
 transition_infos = self.SFCNetworks["Transitions"].pop(transition)
-self.Program += [("%sTRANSITION"%self.CurrentIndent, ())]
+self.Program += [("%sTRANSITION" % self.CurrentIndent, ())]
 if transition_infos["priority"] != None:
 self.Program += [(" (PRIORITY := ", ()),
-("%d"%transition_infos["priority"], (self.TagName, "transition", transition_infos["id"], "priority")),
+("%d" % transition_infos["priority"], (self.TagName, "transition", transition_infos["id"], "priority")),
 (")", ())]
 self.Program += [(" FROM ", ())]
 if len(transition_infos["from"]) > 1:
 self.Program += [("(", ())]
 self.Program += JoinList([(", ", ())], transition_infos["from"])
 else:
 msg = _("Transition with content \"{a1}\" not connected to a next step in \"{a2}\" POU").\
 format(a1 = transition_infos["content"], a2 = self.Name)
 raise PLCGenException, msg
 self.Program += transition_infos["content"]
-self.Program += [("%sEND_TRANSITION\n\n"%self.CurrentIndent, ())]
+self.Program += [("%sEND_TRANSITION\n\n" % self.CurrentIndent, ())]
 for [(step_name, step_infos)] in transition_infos["to"]:
 self.ComputeSFCStep(step_name)
 def GenerateProgram(self, pou):
 self.ComputeInterface(pou)
 self.ComputeConnectionTypes(pou)
 self.ComputeProgram(pou)
-program = [("%s "%self.Type, ()),
+program = [("%s " % self.Type, ()),
 (self.Name, (self.TagName, "name"))]
 if self.ReturnType is not None:
 program += [(" : ", ()),
 (self.ReturnType, (self.TagName, "return"))]
 program += [("\n", ())]
 if len(self.Interface) == 0:
-raise PLCGenException, _("No variable defined in \"%s\" POU")%self.Name
+raise PLCGenException, _("No variable defined in \"%s\" POU") % self.Name
 if len(self.Program) == 0 :
-raise PLCGenException, _("No body defined in \"%s\" POU")%self.Name
+raise PLCGenException, _("No body defined in \"%s\" POU") % self.Name
 var_number = 0
 for list_type, option, located, variables in self.Interface:
 variable_type = errorVarTypes.get(list_type, "var_local")
-program += [("  %s"%list_type, ())]
+program += [("  %s" % list_type, ())]
 if option is not None:
-program += [(" %s"%option, (self.TagName, variable_type, (var_number, var_number + len(variables)), option.lower()))]
+program += [(" %s" % option, (self.TagName, variable_type, (var_number, var_number + len(variables)), option.lower()))]
 program += [("\n", ())]
 for var_type, var_name, var_address, var_initial in variables:
 program += [("    ", ())]
 if var_name:
 program += [(var_name, (self.TagName, variable_type, var_number, "name")),
 program += [(";\n", ())]
 var_number += 1
 program += [("  END_VAR\n", ())]
 program += [("\n", ())]
 program += self.Program
-program += [("END_%s\n\n"%self.Type, ())]
+program += [("END_%s\n\n" % self.Type, ())]
 return program
 def GenerateCurrentProgram(controler, project, errors, warnings):
 generator = ProgramGenerator(controler, project, errors, warnings)
 generator.GenerateProgram()

changeset 1734	750eeb7230a1
parent 1730	64d8f52bc8c8
child 1736	7e61baa047f0