beremiz: comparison PLCGenerator.py

equal deleted inserted replaced

-:fda6c1a37662
+:f62625418bff
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-from __future__ import absolute_import
 import re
 from functools import reduce
 from six.moves import xrange
 from plcopen import PLCOpenParser
 if line_num < len(lines):
 spaces = 0
 while lines[line_num][spaces] == " ":
 spaces += 1
 indent = ""
-for dummy in xrange(spaces, nb_spaces):
+for dummy in range(spaces, nb_spaces):
 indent += " "
 for line in lines:
 if line != "":
 compute += "%s%s\n" % (indent, line)
 else:
 else:
 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():
+for pou_name in list(self.PouComputed.keys()):
 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
 # Generate data type declaration structure if there is at least one data
 # type defined
 if len(self.DatatypeComputed) > 0:
 self.Program += [("TYPE\n", ())]
 # Generate every data types defined
-for datatype_name in self.DatatypeComputed.keys():
+for datatype_name in list(self.DatatypeComputed.keys()):
 log("Generate Data Type %s"%datatype_name)
 self.GenerateDataType(datatype_name)
 self.Program += [("END_TYPE\n\n", ())]
 # Generate every POUs defined
-for pou_name in self.PouComputed.keys():
+for pou_name in list(self.PouComputed.keys()):
 log("Generate POU %s"%pou_name)
 self.GeneratePouProgram(pou_name)
 if noconfig:
 return
 # Generate every configurations defined
 else:
 self.ConnectionTypes[variable.connectionPointIn] = itype
 if connected is not None and connected not in self.ConnectionTypes:
 for connection in self.ExtractRelatedConnections(connected):
 self.ConnectionTypes[connection] = itype
-for var_type, connections in undefined.items():
+for var_type, connections in list(undefined.items()):
 related = []
 for connection in connections:
 connection_type = self.ConnectionTypes.get(connection)
 if connection_type and not connection_type.startswith("ANY"):
 var_type = connection_type
 self.Program += [(instance.getvariable(), coil_info + ("reference",))]
 self.Program += [(" := ", ())] + expression + [(";\n", ())]
 def FactorizePaths(self, paths):
 same_paths = {}
-uncomputed_index = range(len(paths))
+uncomputed_index = list(range(len(paths)))
 factorized_paths = []
 for num, path in enumerate(paths):
 if isinstance(path, list):
 if len(path) > 1:
 str_path = str(path[-1:])
 same_paths.setdefault(str_path, [])
 same_paths[str_path].append((path[:-1], num))
 else:
 factorized_paths.append(path)
 uncomputed_index.remove(num)
-for same_path, elements in same_paths.items():
+for same_path, elements in list(same_paths.items()):
 if len(elements) > 1:
 elements_paths = self.FactorizePaths([path for path, num in elements])
 if len(elements_paths) > 1:
 factorized_paths.append([tuple(elements_paths)] + eval(same_path))
 else:
 instances.append(body.getcontentInstance(instanceLocalId))
 return instances
 def GenerateSFCStep(self, step, pou):
 step_name = step.getname()
-if step_name not in self.SFCNetworks["Steps"].keys():
+if step_name not in list(self.SFCNetworks["Steps"].keys()):
 if step.getinitialStep():
 self.InitialSteps.append(step_name)
 step_infos = {"id":          step.getlocalId(),
 "initial":     step.getinitialStep(),
 "transitions": [],
 instances.append(transition)
 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():
+if instance in list(self.SFCNetworks["Transitions"].keys()):
 target_info = (self.TagName, "transition", instance.getlocalId(), "to", step_infos["id"])
 self.SFCNetworks["Transitions"][instance]["to"].append([(step_name, target_info)])
 def GenerateSFCJump(self, jump, pou):
 jump_target = jump.gettargetName()
 instances.append(transition)
 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():
+if instance in list(self.SFCNetworks["Transitions"].keys()):
 target_info = (self.TagName, "jump", jump.getlocalId(), "target")
 self.SFCNetworks["Transitions"][instance]["to"].append([(jump_target, target_info)])
 def GenerateSFCStepActions(self, actionBlock, pou):
 connections = actionBlock.connectionPointIn.getconnections()
 if isinstance(body, list):
 body = body[0]
 step = body.getcontentInstance(stepLocalId)
 self.GenerateSFCStep(step, pou)
 step_name = step.getname()
-if step_name in self.SFCNetworks["Steps"].keys():
+if step_name in list(self.SFCNetworks["Steps"].keys()):
 actions = actionBlock.getactions()
 for i, action in enumerate(actions):
 action_infos = {"id":        actionBlock.getlocalId(),
 "qualifier": action["qualifier"],
 "content":   action["value"],
 ("\n", ())], ())
 action_infos["content"] = action_name
 self.SFCNetworks["Steps"][step_name]["actions"].append(action_infos)
 def GenerateSFCAction(self, action_name, pou):
-if action_name not in self.SFCNetworks["Actions"].keys():
+if action_name not in list(self.SFCNetworks["Actions"].keys()):
 actionContent = pou.getaction(action_name)
 if actionContent is not None:
 previous_tagname = self.TagName
 self.TagName = ComputePouActionName(self.Name, action_name)
 self.ComputeProgram(actionContent)
 self.SFCNetworks["Actions"][action_name] = (self.Program, (self.TagName, "name"))
 self.Program = []
 self.TagName = previous_tagname
 def GenerateSFCTransition(self, transition, pou):
-if transition not in self.SFCNetworks["Transitions"].keys():
+if transition not in list(self.SFCNetworks["Transitions"].keys()):
 steps = []
 connections = transition.connectionPointIn.getconnections()
 if connections is not None and len(connections) == 1:
 instanceLocalId = connections[0].getrefLocalId()
 body = pou.getbody()
 self.SFCComputedBlocks += self.Program
 self.Program = []
 for step in steps:
 self.GenerateSFCStep(step, pou)
 step_name = step.getname()
-if step_name in self.SFCNetworks["Steps"].keys():
+if step_name in list(self.SFCNetworks["Steps"].keys()):
 transition_infos["from"].append([(step_name, (self.TagName, "transition", transition.getlocalId(), "from", step.getlocalId()))])
 self.SFCNetworks["Steps"][step_name]["transitions"].append(transition)
 def ComputeSFCStep(self, step_name):
-if step_name in self.SFCNetworks["Steps"].keys():
+if step_name in list(self.SFCNetworks["Steps"].keys()):
 step_infos = self.SFCNetworks["Steps"].pop(step_name)
 self.Program += [(self.CurrentIndent, ())]
 if step_infos["initial"]:
 self.Program += [("INITIAL_", ())]
 self.Program += [("STEP ", ()),
 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():
+if action_name in list(self.SFCNetworks["Actions"].keys()):
 action_content, action_info = self.SFCNetworks["Actions"].pop(action_name)
 self.Program += [("%sACTION " % self.CurrentIndent, ()),
 (action_name, action_info),
 (":\n", ())]
 self.Program += action_content
 self.Program += [("%sEND_ACTION\n\n" % self.CurrentIndent, ())]
 def ComputeSFCTransition(self, transition):
-if transition in self.SFCNetworks["Transitions"].keys():
+if transition in list(self.SFCNetworks["Transitions"].keys()):
 transition_infos = self.SFCNetworks["Transitions"].pop(transition)
 self.Program += [("%sTRANSITION" % self.CurrentIndent, ())]
 if transition_infos["priority"] is not None:
 self.Program += [(" (PRIORITY := ", ()),
 ("%d" % transition_infos["priority"], (self.TagName, "transition", transition_infos["id"], "priority")),

branch	python3
changeset 3750	f62625418bff
parent 3704	c17fac18c663
child 3752	9f6f46dbe3ae