plcopeneditor_history: comparison plcopen/structures.py

equal deleted inserted replaced

-:ee18a387e80a
+:0b499416ebd7
 		"ANY_INT" : "if(search_expression_type->is_integer_type(%(paramname)s_param_value))"
 		}.get(typename,
 			"if (typeid(*last_type_symbol) == typeid(%(typename)s_type_name_c))")%{
 					"paramname" : paramname, "typename": typename.lower()}
-	def recurse_and_indent(fdecls, indent):
+	def recurse_and_indent(fdecls, indent, do_type_search_only = False):
 		if type(fdecls) != type(tuple()):
 			res = ""
 			for Paramname, ParamTypes in fdecls.iteritems():
 				res += ("""
 {
-	indentifier_c param_name("%(input_name)s");
+	identifier_c param_name("%(input_name)s");
 	/* Get the value from a foo(<param_name> = <param_value>) style call */
 	symbol_c *%(input_name)s_param_value = function_call_param_iterator.search(&param_name);
 	/* Get the value from a foo(<param_value>) style call */
 	if (%(input_name)s_param_value == NULL)
 	{
 %(if_good_type_code)s
 	}
 """%{
 	"type_test":ANY_to_compiler_test_type_GEN(ParamType,Paramname),
-	"if_good_type_code":recurse_and_indent(NextParamDecl,indent).replace('\n','\n	')})
+	"if_good_type_code":recurse_and_indent(NextParamDecl,indent,do_type_search_only).replace('\n','\n	')})
 				res += """
 	ERROR;
 }
 """
 			fdecl=fdecls[0]
 			result_type_rule = fdecl["return_type_rule"]
 			res += {
 				"copy_input" : "symbol_c * return_type_symbol = last_type_symbol;\n",
-				"defined" : "symbol_c * return_type_symbol = &%s_type_name_c;\n"%fdecl["outputs"][0][1].lower(),
+				"defined" : "symbol_c * return_type_symbol = &search_constant_type_c::%s_type_name;\n"%fdecl["outputs"][0][1].lower(),
 				}.get(result_type_rule, "symbol_c * return_type_symbol = %s;\n"%result_type_rule)
+			if not do_type_search_only:
-			try:
+				try:
-				code_gen = eval(fdecl["python_eval_c_code_format"])
+					code_gen = eval(fdecl["python_eval_c_code_format"])
-			except Exception:
+				except Exception:
-				code_gen = "#error in eval of " + fdecl["name"]
+					code_gen = "#error in eval of " + fdecl["name"]
-			code_gen_dic_decl = {}
+				code_gen_dic_decl = {}
-			for paramname,paramtype,unused in fdecl["inputs"]:
-				code_gen_dic_decl[paramname+"_value"] = '");\n%s_param_value->accept(*this);\ns4o.print("'%(paramname)
-				code_gen_dic_decl[paramname+"_type"] = '");\n%s_type_symbol->accept(*this);\ns4o.print("'%(paramname)
-			code_gen_dic_decl["return_type"] = '");\nreturn_type_symbol->accept(*this);\ns4o.print("'
-			code_gen_dic_decl["param_count"] = '");\ns4o.print_integer(nb_param);\ns4o.print("'
-			if type(code_gen) == type(tuple()):
-				res += 's4o.print("%s");\n'%(code_gen[0]%code_gen_dic_decl)
-				static_param_accept_list = []
 				for paramname,paramtype,unused in fdecl["inputs"]:
-					static_param_accept_list.append("%s_param_value->accept(*this);\n"%(paramname))
+					code_gen_dic_decl[paramname+"_value"] = '");\n%s_param_value->accept(*this);\ns4o.print("'%(paramname)
-				res += ('s4o.print("%s");\n'%(code_gen[1])).join(static_param_accept_list)
+					code_gen_dic_decl[paramname+"_type"] = '");\n%s_type_symbol->accept(*this);\ns4o.print("'%(paramname)
-				code = 's4o.print("%s");\nparam_value->accept(*this);\n'%(code_gen[1])
+				code_gen_dic_decl["return_type"] = '");\nreturn_type_symbol->accept(*this);\ns4o.print("'
-				end_code = 's4o.print("%s");\nreturn NULL;\n'%(code_gen[2])
+				code_gen_dic_decl["param_count"] = '");\ns4o.print_integer(nb_param);\ns4o.print("'
-			else:
-				code = ''
+				if type(code_gen) == type(tuple()):
-				end_code = ('s4o.print("' + code_gen%code_gen_dic_decl + '");\nreturn NULL;\n').replace('s4o.print("");\n','')
+					res += 's4o.print("%s");\n'%(code_gen[0]%code_gen_dic_decl)
+					static_param_accept_list = []
-			if fdecl["extensible"]:
+					for paramname,paramtype,unused in fdecl["inputs"]:
-				res += ("""
+						static_param_accept_list.append("%s_param_value->accept(*this);\n"%(paramname))
-int base_num = %d
+					res += ('s4o.print("%s");\n'%(code_gen[1])).join(static_param_accept_list)
+					code = 's4o.print("%s");\nparam_value->accept(*this);\n'%(code_gen[1])
+					end_code = 's4o.print("%s");\nreturn NULL;\n'%(code_gen[2])
+				else:
+					code = ''
+					end_code = ('s4o.print("' + code_gen%code_gen_dic_decl + '");\nreturn NULL;\n').replace('s4o.print("");\n','')
+				if fdecl["extensible"]:
+					res += ("""
+int base_num = %d;
+symbol_c *param_value = NULL;
 do{
 	char my_name[10];
 	sprintf(my_name, "IN%%d", base_num++);
-	indentifier_c param_name(my_name);
+	identifier_c param_name(my_name);
 	/* Get the value from a foo(<param_name> = <param_value>) style call */
-	symbol_c *param_value = function_call_param_iterator.search(&param_name);
+	param_value = function_call_param_iterator.search(&param_name);
 	/* Get the value from a foo(<param_value>) style call */
 	if (param_value == NULL)
 	  param_value = function_call_param_iterator.next();
 	if (param_value != NULL){
 		/*Function specific CODE */
 		%s
 	}
-}while(param_value != NULL)
+}while(param_value != NULL);
 %s
 """%(fdecl["baseinputnumber"]+2, code.replace('\n','\n		'), end_code))
+				else:
+					#res += code + end_code
+					res += end_code
 			else:
-				#res += code + end_code
+				res += "return return_type_symbol;\n"
-				res += end_code
 			return res.replace('\n','\n'+indent)
 ###################################################################
 ###                                                             ###
 ###                           MAIN                              ###
 	# Keep ptrack of original order in a separated list
 	std_fdecls = {}
 	official_order = []
 	for section in std_decl:
 		for fdecl in section["list"]:
-			if len(official_order)==0 or official_order[-1] != official_order:
+			if len(official_order)==0 or official_order[-1] != fdecl["name"]:
 				official_order.append(fdecl["name"])
 			# store all func by name in a dict
 			std_fdecls_fdecl_name = std_fdecls.get(fdecl["name"], {})
 			current = std_fdecls_fdecl_name
 			for i in fdecl["inputs"]:
 } function_type_t;
 """
 	# Generate the funct thaat return enumerated according function name
 	get_function_type_decl = """
+/****
+* IEC 61131-3 standard function lib
+* generated code, do not edit by hand
+*/
 function_type_t get_function_type(identifier_c *function_name) {
 """
 	for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:
 		get_function_type_decl += """
 	if (!strcasecmp(function_name->value, "%s"))
 """
 	# Generate the part of generate_cc_st_c::visit(function_invocation)
 	# that is responsible to generate C code for std lib calls.
-	st_code_gen = "switch(current_function_type){\n"
+	st_code_gen = """
+/****
+* IEC 61131-3 standard function lib
+* generated code, do not edit by hand
+*/
+switch(current_function_type){
+"""
 	for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:
 		st_code_gen += """
 /****
 *%s
 		st_code_gen += """
 	}/*function_%s*/
 	break;
 """	%(fname.lower())
-	st_code_gen += "}"
+	st_code_gen +=  """
+	case function_none :
+	ERROR;
+}
+return NULL;
+"""
+	# Generate the part of search_expression_type_c::visit(function_invocation)
+	# that is responsible of returning type symbol for function invocation.
+	search_type_code =  """
+/****
+* IEC 61131-3 standard function lib
+* generated code, do not edit by hand
+*/
+switch(current_function_type){
+"""
+	for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:
+		search_type_code += """
+/****
+*%s
+*/
+	case function_%s :
+	{
+		symbol_c *last_type_symbol = NULL;
+"""	%(fname, fname.lower())
+		indent =  "	"
+		search_type_code += recurse_and_indent(fdecls, indent, True).replace('\n','\n	')
+		search_type_code += """
+	}/*function_%s*/
+	break;
+"""	%(fname.lower())
+	search_type_code += """
+	case function_none :
+	ERROR;
+}
+return NULL;
+"""
 	# Now, print that out, or write to files from sys.argv
-	print function_type_decl
+	for name, ext in [
-	print get_function_type_decl
+			('function_type_decl','h'),
-	print st_code_gen #.replace("\n", "\\\n")
+			('get_function_type_decl','c'),
+			('st_code_gen','c'),
+			('search_type_code','c')]:
+		fd = open(os.path.join(sys.argv[1],name+'.'+ext),'w')
+		fd.write(eval(name))
+		fd.close()
 else:
 	# Put standard functions declaration in Bloktypes
 	BlockTypes.extend(get_standard_funtions(csv_file_to_table(open(os.path.join(sys.path[0], "plcopen/iec_std.csv")))))

changeset 19	0b499416ebd7
parent 18	ee18a387e80a
child 21	e619d7bea692