matiec: comparison stage3/fill_candidate

equal deleted inserted replaced

-:31e3b3f2eff1
+:5074236fb3c4
 fill_candidate_datatypes_c::fill_candidate_datatypes_c(symbol_c *ignore) {
 	il_operand = NULL;
 	prev_il_instruction = NULL;
-	search_varfb_instance_type = NULL;
+	search_var_instance_decl = NULL;
 	current_enumerated_spec_type = NULL;
 }
 fill_candidate_datatypes_c::~fill_candidate_datatypes_c(void) {
 }
 /* handle implicit FB call in IL.
 * e.g.  CLK ton_var
 *        CU counter_var
 */
 void *fill_candidate_datatypes_c::handle_implicit_il_fb_call(symbol_c *il_instruction, const char *param_name, symbol_c *&called_fb_declaration) {
-	symbol_c *fb_decl = (NULL == il_operand)? NULL : search_varfb_instance_type->get_basetype_decl(il_operand);
+	symbol_c *fb_decl = (NULL == il_operand)? NULL : search_var_instance_decl->get_basetype_decl(il_operand);
 	if (! get_datatype_info_c::is_function_block(fb_decl)) fb_decl = NULL;
 	/* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */
 	/* However, when calling using the 'S' and 'R' operators, this error is not caught by stage 2, as these operators have two possible semantics */
 	// if (NULL == fb_type_id) ERROR;
 /*********************/
 void *fill_candidate_datatypes_c::visit(symbolic_variable_c *symbol) {
 	/*  NOTE: We need to fully determine the datatype of each element in the structured_variable inside this fill_candidate_datatypes class!
 	 *        Basically, for variables (be they symbolic_variable, structured_variable, array_variable), we do the narrow algorithm
 	 *        in this fill_candidate_datatypes_c itself!
-	 *        This is needed because we need to know in which scope (i.e. the datatype of the recor_variable in a structtured_variable_c)
+	 *        This is needed because we need to know in which scope (i.e. the datatype of the record_variable in a structtured_variable_c)
-	 *        we will search for the field_variable of the structured_variable_c
+	 *        we will search for the field_variable of the structured_variable_c. Similarly, it is also used to determine the datatype
+	 *        to which a REF_TO variable points to.
 	 */
-	symbol->datatype = search_varfb_instance_type->get_basetype_decl(symbol); // Do the narrow algorithm in this fill_candidate_datatypes_c!!
+	symbol->datatype = search_var_instance_decl->get_basetype_decl(symbol); // Do the narrow algorithm in this fill_candidate_datatypes_c!!
 	add_datatype_to_candidate_list(symbol, symbol->datatype); /* will only add if non NULL */
 	if (debug) std::cout << "VAR [" << symbol->candidate_datatypes.size() << "]\n";
 	return NULL;
 }
 /* B 1.4.2 - Multi-element variables */
 /*************************************/
 /*  subscripted_variable '[' subscript_list ']' */
 // SYM_REF2(array_variable_c, subscripted_variable, subscript_list)
 void *fill_candidate_datatypes_c::visit(array_variable_c *symbol) {
-	/* get the declaration of the data type __stored__ in the array... */
-	/* if we were to want the data type of the array itself, then we should call_param_name
-	 * search_varfb_instance_type->get_basetype_decl(symbol->subscripted_variable)
-	 */
-	add_datatype_to_candidate_list(symbol, search_varfb_instance_type->get_basetype_decl(symbol));   /* will only add if non NULL */
-	/*  NOTE: We need to fully determine the datatype of each element in the structured_variable inside this fill_candidate_datatypes class!
-	 *        Basically, for variables (be they symbolic_variable, structured_variable, array_variable), we do the narrow algorithm
-	 *        in this fill_candidate_datatypes_c itself!
-	 *        This is needed because we need to know in which scope (i.e. the datatype of the recor_variable in a structtured_variable_c)
-	 *        we will search for the field_variable of the structured_variable_c
-	 */
-	if (symbol->candidate_datatypes.size() == 1)
-	  // narrow the symbol->datatype for this strcutured_variable as explained above!
-	  symbol->datatype = symbol->candidate_datatypes[0];
-	/* recursively call the subscript list, so we can check the data types of the expressions used for the subscripts */
-	symbol->subscript_list->accept(*this);
 	/* recursively call the subscripted_variable. We need to do this since the array variable may be stored inside a structured
 	 * variable (i.e. if it is an element inside a struct), in which case we want to recursively visit every element of the struct,
 	 * as it may contain more arrays whose subscripts must also be visited!
 	 * e.g.   structvar.a1[v1+2].b1.c1[v2+3].d1
 	 *        TYPE
 	 *        VAR
 	 *          structvar: a_s;
 	 *        END_VAR
 	 */
 	symbol->subscripted_variable->accept(*this);
+	add_datatype_to_candidate_list(symbol, search_base_type_c::get_basetype_decl(get_datatype_info_c::get_array_storedtype_id(symbol->subscripted_variable->datatype)));   /* will only add if non NULL */
+	/*  NOTE: We need to fully determine the datatype of each element in the structured_variable inside this fill_candidate_datatypes class!
+	 *        Basically, for variables (be they symbolic_variable, structured_variable, array_variable), we do the narrow algorithm
+	 *        in this fill_candidate_datatypes_c itself!
+	 *        This is needed because we need to know in which scope (i.e. the datatype of the record_variable in a structtured_variable_c)
+	 *        we will search for the field_variable of the structured_variable_c. Similarly, it is also used to determine the datatype
+	 *        to which a REF_TO variable points to.
+	 */
+	if (symbol->candidate_datatypes.size() == 1)
+	  // narrow the symbol->datatype for this array_variable as explained above!
+	  symbol->datatype = symbol->candidate_datatypes[0];
+	/* recursively call the subscript list, so we can check the data types of the expressions used for the subscripts */
+	symbol->subscript_list->accept(*this);
 	if (debug) std::cout << "ARRAY_VAR [" << symbol->candidate_datatypes.size() << "]\n";
 	return NULL;
 }
 	symbol->record_variable->accept(*this);
 	/*  NOTE: We need to fully determine the datatype of each element in the structured_variable inside this fill_candidate_datatypes class!
 	 *        Basically, for variables (be they symbolic_variable, structured_variable, array_variable), we do the narrow algorithm
 	 *        in this fill_candidate_datatypes_c itself!
-	 *        This is needed because we need to know in which scope (i.e. the datatype of the recor_variable in a structtured_variable_c)
+	 *        This is needed because we need to know in which scope (i.e. the datatype of the record_variable in a structtured_variable_c)
-	 *        we will search for the field_variable of the structured_variable_c
+	 *        we will search for the field_variable of the structured_variable_c. Similarly, it is also used to determine the datatype
+	 *        to which a REF_TO variable points to.
 	 */
 	if (NULL != symbol->record_variable->datatype)
 	  // We relly on the fact that we have already narrowed the symbol->datatype for the record variable, and use it as the scope in which the filed_variable is declared!
 	  add_datatype_to_candidate_list(symbol, search_base_type_c::get_basetype_decl(get_datatype_info_c::get_struct_field_type_id(symbol->record_variable->datatype, symbol->field_selector)));  /* will only add if non NULL */
 	if (symbol->candidate_datatypes.size() == 1)
 /* B 1.4.3 - Declaration & Initialisation */
 /******************************************/
 void *fill_candidate_datatypes_c::visit(var1_list_c *symbol) {
 for(int i = 0; i < symbol->n; i++) {
-/* We don't really need to set the datatype of each variable. We just check the declaration itself!
-add_datatype_to_candidate_list(symbol->elements[i], search_varfb_instance_type->get_basetype_decl(symbol->elements[i])); // will only add if non NULL
-*/
 symbol->elements[i]->accept(*this); // handle the extensible_input_parameter_c, etc...
 }
 return NULL;
 }
 void *fill_candidate_datatypes_c::visit(function_declaration_c *symbol) {
 	if (debug) printf("Filling candidate data types list of function %s\n", ((token_c *)(symbol->derived_function_name))->value);
 	local_enumerated_value_symtable.reset();
 	symbol->var_declarations_list->accept(populate_enumvalue_symtable);
-	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);
+	search_var_instance_decl = new search_var_instance_decl_c(symbol);
 	symbol->var_declarations_list->accept(*this);
 	symbol->function_body->accept(*this);
-	delete search_varfb_instance_type;
+	delete search_var_instance_decl;
-	search_varfb_instance_type = NULL;
+	search_var_instance_decl = NULL;
 	local_enumerated_value_symtable.reset();
 	return NULL;
 }
 void *fill_candidate_datatypes_c::visit(function_block_declaration_c *symbol) {
 	if (debug) printf("Filling candidate data types list of FB %s\n", ((token_c *)(symbol->fblock_name))->value);
 	local_enumerated_value_symtable.reset();
 	symbol->var_declarations->accept(populate_enumvalue_symtable);
-	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);
+	search_var_instance_decl = new search_var_instance_decl_c(symbol);
 	symbol->var_declarations->accept(*this);
 	symbol->fblock_body->accept(*this);
-	delete search_varfb_instance_type;
+	delete search_var_instance_decl;
-	search_varfb_instance_type = NULL;
+	search_var_instance_decl = NULL;
 	local_enumerated_value_symtable.reset();
 	/* The FB declaration itself may be used as a dataype! We now do the fill algorithm considering
 	 * function_block_declaration_c a data type declaration...
 void *fill_candidate_datatypes_c::visit(program_declaration_c *symbol) {
 	if (debug) printf("Filling candidate data types list in program %s\n", ((token_c *)(symbol->program_type_name))->value);
 	local_enumerated_value_symtable.reset();
 	symbol->var_declarations->accept(populate_enumvalue_symtable);
-	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);
+	search_var_instance_decl = new search_var_instance_decl_c(symbol);
 	symbol->var_declarations->accept(*this);
 	symbol->function_block_body->accept(*this);
-	delete search_varfb_instance_type;
+	delete search_var_instance_decl;
-	search_varfb_instance_type = NULL;
+	search_var_instance_decl = NULL;
 	local_enumerated_value_symtable.reset();
 	return NULL;
 }
 * | il_call_operator prev_declared_fb_name '(' eol_list il_param_list ')'
 */
 /* NOTE: The parameter 'called_fb_declaration'is used to pass data between stage 3 and stage4 */
 // SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list, symbol_c *called_fb_declaration)
 void *fill_candidate_datatypes_c::visit(il_fb_call_c *symbol) {
-	symbol_c *fb_decl = search_varfb_instance_type->get_basetype_decl(symbol->fb_name);
+	symbol_c *fb_decl = search_var_instance_decl->get_basetype_decl(symbol->fb_name);
 	if (! get_datatype_info_c::is_function_block(fb_decl)) fb_decl = NULL;
 	/* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */
 	if (NULL == fb_decl) ERROR;
 }
 /*  NOTE: We need to fully determine the datatype of each element in the structured_variable inside this fill_candidate_datatypes class!
 *        Basically, for variables (be they symbolic_variable, structured_variable, array_variable), we do the narrow algorithm
 *        in this fill_candidate_datatypes_c itself!
-*        This is needed because we need to know in which scope (i.e. the datatype of the recor_variable in a structtured_variable_c)
+*        This is needed because we need to know in which scope (i.e. the datatype of the record_variable in a structtured_variable_c)
-*        we will search for the field_variable of the structured_variable_c
+*        we will search for the field_variable of the structured_variable_c. Similarly, it is also used to determine the datatype
+*        to which a REF_TO variable points to.
 *
 *        Since the deref_operator_c may be used inside structures, we must narrow it here, if possible!
 */
 if (symbol->candidate_datatypes.size() == 1)
 // narrow the symbol->datatype for this symbol as explained above!
 /*****************************************/
 /* B 3.2.2 Subprogram Control Statements */
 /*****************************************/
 void *fill_candidate_datatypes_c::visit(fb_invocation_c *symbol) {
-	symbol_c *fb_decl = search_varfb_instance_type->get_basetype_decl(symbol->fb_name);
+	symbol_c *fb_decl = search_var_instance_decl->get_basetype_decl(symbol->fb_name);
 	if (! get_datatype_info_c::is_function_block(fb_decl )) fb_decl = NULL;
 	if (NULL == fb_decl) ERROR; /* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */
 	if (symbol->   formal_param_list != NULL) symbol->formal_param_list->accept(*this);
 	if (symbol->nonformal_param_list != NULL) symbol->nonformal_param_list->accept(*this);

changeset 939	5074236fb3c4
parent 938	31e3b3f2eff1
child 940	61e2bdae5899