diff -r 27f246b35ac2 -r 783ef40344dd stage3/fill_candidate_datatypes.cc --- a/stage3/fill_candidate_datatypes.cc Tue Aug 20 11:11:09 2013 +0100 +++ b/stage3/fill_candidate_datatypes.cc Tue Aug 20 11:15:40 2013 +0100 @@ -555,17 +555,13 @@ * 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_type_id = search_varfb_instance_type->get_basetype_id(il_operand); - /* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */ - if (NULL == fb_type_id) ERROR; - - function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(fb_type_id); - if (function_block_type_symtable.end_value() == fb_decl) - /* The il_operand is not the name of a FB instance. Most probably it is the name of a variable of some other type. - * this is a semantic error. - */ - fb_decl = NULL; - + symbol_c *fb_decl = (NULL == il_operand)? NULL : search_varfb_instance_type->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; + /* The narrow_candidate_datatypes_c does not rely on this called_fb_declaration pointer being == NULL to conclude that * we have a datatype incompatibility error, so we set it to fb_decl to allow the print_datatype_error_c to print out * more informative error messages! @@ -594,10 +590,54 @@ + +/* handle the S and R IL operators... */ +/* operator_str should be set to either "S" or "R" */ +void *fill_candidate_datatypes_c::handle_S_and_R_operator(symbol_c *symbol, const char *operator_str, symbol_c *&called_fb_declaration) { + /* NOTE: this operator has two possible semantic meanings: + * - Set/Reset the BOOL operand variable to true + * - call the FB specified by the operand. + * Which of the two semantics will have to be determined by the datatype of the operand! + */ + symbol_c *prev_instruction_type, *operand_type; + + if (NULL == prev_il_instruction) return NULL; + if (NULL == il_operand) return NULL; + + for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) { + for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) { + prev_instruction_type = prev_il_instruction->candidate_datatypes[i]; + operand_type = il_operand->candidate_datatypes[j]; + /* IEC61131-3, Table 52, Note (e) states that the datatype of the operand must be BOOL! + * IEC61131-3, Table 52, line 3 states that this operator should "Set operand to 1 if current result is Boolean 1" + * which implies that the prev_instruction_type MUST also be BOOL compatible. + */ + if (get_datatype_info_c::is_BOOL_compatible(prev_instruction_type) && get_datatype_info_c::is_BOOL_compatible(operand_type)) + add_datatype_to_candidate_list(symbol, prev_instruction_type); + } + } + + /* if the appropriate semantics is not a Set/Reset of a boolean variable, the we try for the FB invocation! */ + if (symbol->candidate_datatypes.size() == 0) + handle_implicit_il_fb_call(symbol, operator_str, called_fb_declaration); + + /* If it is also not a valid FB call, make sure the candidate_datatypes is empty (handle_implicit_il_fb_call may leave it non-empty!!) */ + /* From here on out, all later code will consider the symbol->called_fb_declaration being NULL as an indication that this operator must use the + * Set/Reset semantics, so we must also guarantee that the remainder of the state of this symbol is compatible with that assumption! + */ + if (NULL == called_fb_declaration) + symbol->candidate_datatypes.clear(); + + if (debug) std::cout << operator_str << " [" << prev_il_instruction->candidate_datatypes.size() << "," << il_operand->candidate_datatypes.size() << "] ==> " << symbol->candidate_datatypes.size() << " result.\n"; + return NULL; +} + + + /* handle a binary IL operator, like ADD, SUB, etc... */ void *fill_candidate_datatypes_c::handle_binary_operator(const struct widen_entry widen_table[], symbol_c *symbol, symbol_c *l_expr, symbol_c *r_expr) { - if (NULL == l_expr) /* if no prev_il_instruction */ - return NULL; + if (NULL == l_expr) return NULL; /* if no prev_il_instruction */ + if (NULL == r_expr) return NULL; /* if no IL operand!! */ for(unsigned int i = 0; i < l_expr->candidate_datatypes.size(); i++) for(unsigned int j = 0; j < r_expr->candidate_datatypes.size(); j++) @@ -1553,21 +1593,11 @@ * | il_call_operator prev_declared_fb_name '(' il_operand_list ')' * | 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 (although currently it is not used in stage 4 */ +/* 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) { - /* We do not call - * fb_decl = search_varfb_instance_type->get_basetype_decl(symbol->fb_name); - * because we want to make sure it is a FB instance, and not some other data type... - */ - symbol_c *fb_type_id = search_varfb_instance_type->get_basetype_id(symbol->fb_name); - /* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */ - if (NULL == fb_type_id) ERROR; - - function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(fb_type_id); - if (function_block_type_symtable.end_value() == fb_decl) - /* The fb_name not the name of a FB instance. Most probably it is the name of a variable of some other type. */ - fb_decl = NULL; + symbol_c *fb_decl = search_varfb_instance_type->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; @@ -1664,6 +1694,7 @@ /* B 2.2 Operators */ /*******************/ void *fill_candidate_datatypes_c::visit(LD_operator_c *symbol) { + if (NULL == il_operand) return NULL; for(unsigned int i = 0; i < il_operand->candidate_datatypes.size(); i++) { add_datatype_to_candidate_list(symbol, il_operand->candidate_datatypes[i]); } @@ -1672,6 +1703,7 @@ } void *fill_candidate_datatypes_c::visit(LDN_operator_c *symbol) { + if (NULL == il_operand) return NULL; for(unsigned int i = 0; i < il_operand->candidate_datatypes.size(); i++) { if (get_datatype_info_c::is_ANY_BIT_compatible(il_operand->candidate_datatypes[i])) add_datatype_to_candidate_list(symbol, il_operand->candidate_datatypes[i]); @@ -1684,6 +1716,7 @@ symbol_c *prev_instruction_type, *operand_type; if (NULL == prev_il_instruction) return NULL; + if (NULL == il_operand) return NULL; for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) { for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) { prev_instruction_type = prev_il_instruction->candidate_datatypes[i]; @@ -1700,6 +1733,7 @@ symbol_c *prev_instruction_type, *operand_type; if (NULL == prev_il_instruction) return NULL; + if (NULL == il_operand) return NULL; for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) { for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) { prev_instruction_type = prev_il_instruction->candidate_datatypes[i]; @@ -1720,6 +1754,7 @@ * We do not need to generate an error message. This error will be caught somewhere else! */ if (NULL == prev_il_instruction) return NULL; + if (NULL == il_operand) return NULL; for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) { if (get_datatype_info_c::is_ANY_BIT_compatible(prev_il_instruction->candidate_datatypes[i])) add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]); @@ -1729,58 +1764,17 @@ } -void *fill_candidate_datatypes_c::visit(S_operator_c *symbol) { - /* TODO: what if this is a FB call ?? */ - symbol_c *prev_instruction_type, *operand_type; - - if (NULL == prev_il_instruction) return NULL; - for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) { - for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) { - prev_instruction_type = prev_il_instruction->candidate_datatypes[i]; - operand_type = il_operand->candidate_datatypes[j]; - /* TODO: I believe the following is wrong! The data types of prev_instruction_type and operand_type DO NOT have to be equal. - * the prev_instruction_type MUST be BOOL compatible. - * I am not too sure about operand_type, does it have to be BOOL compatible, or can it be ANY_BIT compatible? Must check! - */ - if (get_datatype_info_c::is_type_equal(prev_instruction_type,operand_type) && get_datatype_info_c::is_BOOL_compatible(operand_type)) - add_datatype_to_candidate_list(symbol, prev_instruction_type); - } - } - if (debug) std::cout << "S [" << prev_il_instruction->candidate_datatypes.size() << "," << il_operand->candidate_datatypes.size() << "] ==> " << symbol->candidate_datatypes.size() << " result.\n"; - return NULL; -} - - -void *fill_candidate_datatypes_c::visit(R_operator_c *symbol) { - /* TODO: what if this is a FB call ?? */ - symbol_c *prev_instruction_type, *operand_type; - - if (NULL == prev_il_instruction) return NULL; - for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) { - for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) { - prev_instruction_type = prev_il_instruction->candidate_datatypes[i]; - operand_type = il_operand->candidate_datatypes[j]; - /* TODO: I believe the following is wrong! The data types of prev_instruction_type and operand_type DO NOT have to be equal. - * the prev_instruction_type MUST be BOOL compatible. - * I am not too sure about operand_type, does it have to be BOOL compatible, or can it be ANY_BIT compatible? Must check! - */ - if (get_datatype_info_c::is_type_equal(prev_instruction_type,operand_type) && get_datatype_info_c::is_BOOL_compatible(operand_type)) - add_datatype_to_candidate_list(symbol, prev_instruction_type); - } - } - if (debug) std::cout << "R [" << prev_il_instruction->candidate_datatypes.size() << "," << il_operand->candidate_datatypes.size() << "] ==> " << symbol->candidate_datatypes.size() << " result.\n"; - return NULL; -} - - -void *fill_candidate_datatypes_c::visit( S1_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "S1", symbol->called_fb_declaration);} -void *fill_candidate_datatypes_c::visit( R1_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "R1", symbol->called_fb_declaration);} +void *fill_candidate_datatypes_c::visit( S_operator_c *symbol) {return handle_S_and_R_operator (symbol, "S", symbol->called_fb_declaration);} +void *fill_candidate_datatypes_c::visit( R_operator_c *symbol) {return handle_S_and_R_operator (symbol, "R", symbol->called_fb_declaration);} + +void *fill_candidate_datatypes_c::visit( S1_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "S1", symbol->called_fb_declaration);} +void *fill_candidate_datatypes_c::visit( R1_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "R1", symbol->called_fb_declaration);} void *fill_candidate_datatypes_c::visit( CLK_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "CLK", symbol->called_fb_declaration);} -void *fill_candidate_datatypes_c::visit( CU_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "CU", symbol->called_fb_declaration);} -void *fill_candidate_datatypes_c::visit( CD_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "CD", symbol->called_fb_declaration);} -void *fill_candidate_datatypes_c::visit( PV_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "PV", symbol->called_fb_declaration);} -void *fill_candidate_datatypes_c::visit( IN_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "IN", symbol->called_fb_declaration);} -void *fill_candidate_datatypes_c::visit( PT_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "PT", symbol->called_fb_declaration);} +void *fill_candidate_datatypes_c::visit( CU_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "CU", symbol->called_fb_declaration);} +void *fill_candidate_datatypes_c::visit( CD_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "CD", symbol->called_fb_declaration);} +void *fill_candidate_datatypes_c::visit( PV_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "PV", symbol->called_fb_declaration);} +void *fill_candidate_datatypes_c::visit( IN_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "IN", symbol->called_fb_declaration);} +void *fill_candidate_datatypes_c::visit( PT_operator_c *symbol) {return handle_implicit_il_fb_call(symbol, "PT", symbol->called_fb_declaration);} void *fill_candidate_datatypes_c::visit( AND_operator_c *symbol) {return handle_binary_operator(widen_AND_table, symbol, prev_il_instruction, il_operand);} void *fill_candidate_datatypes_c::visit( OR_operator_c *symbol) {return handle_binary_operator( widen_OR_table, symbol, prev_il_instruction, il_operand);} @@ -1969,17 +1963,9 @@ /* B 3.2.2 Subprogram Control Statements */ /*****************************************/ void *fill_candidate_datatypes_c::visit(fb_invocation_c *symbol) { - symbol_c *fb_type_id = search_varfb_instance_type->get_basetype_id(symbol->fb_name); - /* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */ - if (NULL == fb_type_id) ERROR; - - function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(fb_type_id); - if (function_block_type_symtable.end_value() == fb_decl) - /* The fb_name not the name of a FB instance. Most probably it is the name of a variable of some other type. */ - 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; + symbol_c *fb_decl = search_varfb_instance_type->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);