diff -r 94c11207aa6f -r 6014ef82a98a PLCGenerator.py --- a/PLCGenerator.py Fri Sep 30 17:16:02 2011 +0200 +++ b/PLCGenerator.py Sun Oct 09 19:51:14 2011 +0200 @@ -40,6 +40,12 @@ pouTypeNames = {"function" : "FUNCTION", "functionBlock" : "FUNCTION_BLOCK", "program" : "PROGRAM"} +errorVarTypes = { + "VAR_INPUT": "var_input", + "VAR_OUTPUT": "var_output", + "VAR_INOUT": "var_inout", +} + # Helper function for reindenting text def ReIndentText(text, nb_spaces): compute = "" @@ -247,57 +253,39 @@ var_number = 0 # Generate any global variable in configuration for varlist in configuration.getglobalVars(): + variable_type = errorVarTypes.get("VAR_GLOBAL", "var_local") # Generate variable block with modifier config += [(" VAR_GLOBAL", ())] if varlist.getconstant(): - config += [(" CONSTANT", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "constant"))] + config += [(" CONSTANT", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "constant"))] elif varlist.getretain(): - config += [(" RETAIN", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "retain"))] + config += [(" RETAIN", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "retain"))] elif varlist.getnonretain(): - config += [(" NON_RETAIN", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "non_retain"))] + 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.getvariable(): vartype_content = var.gettype().getcontent() - # Variable type is a user data type if vartype_content["name"] == "derived": var_type = vartype_content["value"].getname() - # Variable type is a string type - elif vartype_content["name"] in ["string", "wstring"]: - var_type = vartype_content["name"].upper() - # Variable type is an array - elif vartype_content["name"] == "array": - base_type = vartype_content["value"].baseType.getcontent() - # Array derived directly from a user defined type - if base_type["name"] == "derived": - basetype_name = base_type["value"].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"] - var_type = "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content["value"].getdimension())), basetype_name) - # Variable type is an elementary type - else: - var_type = vartype_content["name"] + self.GenerateDataType(var_type) + config += [(" ", ()), - (var.getname(), (tagname, "variable", var_number, "name")), + (var.getname(), (tagname, variable_type, var_number, "name")), (" ", ())] # Generate variable address if exists address = var.getaddress() if address: config += [("AT ", ()), - (address, (tagname, "variable", var_number, "address")), + (address, (tagname, variable_type, var_number, "address")), (" ", ())] config += [(": ", ()), - (var_type, (tagname, "variable", var_number, "type"))] + (var.gettypeAsText(), (tagname, variable_type, var_number, "type"))] # Generate variable initial value if exists initial = var.getinitialValue() if initial: config += [(" := ", ()), - (self.ComputeValue(initial.getvalue(), var_type), (tagname, "variable", var_number, "initial"))] + (self.ComputeValue(initial.getvalue(), var_type), (tagname, variable_type, var_number, "initial"))] config += [(";\n", ())] var_number += 1 config += [(" END_VAR\n", ())] @@ -316,57 +304,39 @@ var_number = 0 # Generate any global variable in configuration for varlist in resource.getglobalVars(): + variable_type = errorVarTypes.get("VAR_GLOBAL", "var_local") # Generate variable block with modifier resrce += [(" VAR_GLOBAL", ())] if varlist.getconstant(): - resrce += [(" CONSTANT", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "constant"))] + resrce += [(" CONSTANT", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "constant"))] elif varlist.getretain(): - resrce += [(" RETAIN", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "retain"))] + resrce += [(" RETAIN", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "retain"))] elif varlist.getnonretain(): - resrce += [(" NON_RETAIN", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "non_retain"))] + 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() - # Variable type is a user data type if vartype_content["name"] == "derived": var_type = vartype_content["value"].getname() - # Variable type is a string type - elif vartype_content["name"] in ["string", "wstring"]: - var_type = vartype_content["name"].upper() - # Variable type is an array - elif vartype_content["name"] == "array": - base_type = vartype_content["value"].baseType.getcontent() - # Array derived directly from a user defined type - if base_type["name"] == "derived": - basetype_name = base_type["value"].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"] - var_type = "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content["value"].getdimension())), basetype_name) - # Variable type is an elementary type - else: - var_type = vartype_content["name"] + self.GenerateDataType(var_type) + resrce += [(" ", ()), - (var.getname(), (tagname, "variable", var_number, "name")), + (var.getname(), (tagname, variable_type, var_number, "name")), (" ", ())] address = var.getaddress() # Generate variable address if exists if address: resrce += [("AT ", ()), - (address, (tagname, "variable", var_number, "address")), + (address, (tagname, variable_type, var_number, "address")), (" ", ())] resrce += [(": ", ()), - (var_type, (tagname, "variable", var_number, "type"))] + (var.gettypeAsText(), (tagname, variable_type, var_number, "type"))] # Generate variable initial value if exists initial = var.getinitialValue() if initial: resrce += [(" := ", ()), - (self.ComputeValue(initial.getvalue(), var_type), (tagname, "variable", var_number, "initial"))] + (self.ComputeValue(initial.getvalue(), var_type), (tagname, variable_type, var_number, "initial"))] resrce += [(";\n", ())] var_number += 1 resrce += [(" END_VAR\n", ())] @@ -598,6 +568,7 @@ else: variables.append(variable) else: + self.ParentGenerator.GenerateDataType(var_type) initial = var.getinitialValue() if initial: initial_value = initial.getvalue() @@ -609,30 +580,13 @@ else: variables.append((vartype_content["value"].getname(), var.getname(), None, initial_value)) else: + var_type = var.gettypeAsText() initial = var.getinitialValue() if initial: initial_value = initial.getvalue() else: initial_value = None address = var.getaddress() - if vartype_content["name"] in ["string", "wstring"]: - var_type = vartype_content["name"].upper() - # Variable type is an array - elif vartype_content["name"] == "array": - base_type = vartype_content["value"].baseType.getcontent() - # Array derived directly from a user defined type - if base_type["name"] == "derived": - basetype_name = base_type["value"].getname() - self.ParentGenerator.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"] - var_type = "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (x.getlower(), x.getupper()), vartype_content["value"].getdimension())), basetype_name) - else: - var_type = vartype_content["name"] if address is not None: located.append((var_type, var.getname(), address, initial_value)) else: @@ -879,6 +833,10 @@ 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) + if block_infos is None: + raise PLCGenException, _("Undefined block type \"%s\" in \"%s\" POU")%(block_type, self.Name) block_infos["generate"](self, instance, block_infos, body, None) elif isinstance(instance, plcopen.commonObjects_connector): connector = instance.getname() @@ -934,6 +892,10 @@ 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) + if block_infos is None: + raise PLCGenException, _("Undefined block type \"%s\" in \"%s\" POU")%(block_type, self.Name) paths.append(str(block_infos["generate"](self, next, block_infos, body, connection, order))) elif isinstance(next, plcopen.commonObjects_continuation): name = next.getname() @@ -1331,24 +1293,25 @@ 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, ())] if option is not None: - program += [(" %s"%option, (self.TagName, "variable", (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", var_number, "name")), + program += [(var_name, (self.TagName, variable_type, var_number, "name")), (" ", ())] if var_address != None: program += [("AT ", ()), - (var_address, (self.TagName, "variable", var_number, "address")), + (var_address, (self.TagName, variable_type, var_number, "address")), (" ", ())] program += [(": ", ()), - (var_type, (self.TagName, "variable", var_number, "type"))] + (var_type, (self.TagName, variable_type, var_number, "type"))] if var_initial != None: program += [(" := ", ()), - (self.ParentGenerator.ComputeValue(var_initial, var_type), (self.TagName, "variable", var_number, "initial"))] + (self.ParentGenerator.ComputeValue(var_initial, var_type), (self.TagName, variable_type, var_number, "initial"))] program += [(";\n", ())] var_number += 1 program += [(" END_VAR\n", ())]