425 void *fill_candidate_datatypes_c::visit(binary_integer_c *symbol) {

   446 void *fill_candidate_datatypes_c::visit(integer_c        *symbol) {return handle_any_integer(symbol);}

   426 	handle_any_integer(symbol);

   447 void *fill_candidate_datatypes_c::visit(binary_integer_c *symbol) {return handle_any_integer(symbol);}

   427 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;

   448 void *fill_candidate_datatypes_c::visit(octal_integer_c  *symbol) {return handle_any_integer(symbol);}

   428 	return NULL;

   449 void *fill_candidate_datatypes_c::visit(hex_integer_c    *symbol) {return handle_any_integer(symbol);}

   429 }

   430 

   431 

   432 

   433 void *fill_candidate_datatypes_c::visit(octal_integer_c *symbol) {

   434 	handle_any_integer(symbol);

   435 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;

   436 	return NULL;

   437 }

   438 

   439 

   440 

   441 void *fill_candidate_datatypes_c::visit(hex_integer_c *symbol) {

   442 	handle_any_integer(symbol);

   443 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;

   444 	return NULL;

   445 }

   534 void *fill_candidate_datatypes_c::visit(time_of_day_c *symbol) {

   538 void *fill_candidate_datatypes_c::visit(time_of_day_c   *symbol) {add_datatype_to_candidate_list(symbol, symbol->type_name); return NULL;}

   535 	add_datatype_to_candidate_list(symbol, symbol->type_name);

   539 void *fill_candidate_datatypes_c::visit(date_c          *symbol) {add_datatype_to_candidate_list(symbol, symbol->type_name); return NULL;}

   536 	return NULL;

   540 void *fill_candidate_datatypes_c::visit(date_and_time_c *symbol) {add_datatype_to_candidate_list(symbol, symbol->type_name); return NULL;}

   537 }

   538 

   539 void *fill_candidate_datatypes_c::visit(date_c *symbol) {

   540 	add_datatype_to_candidate_list(symbol, symbol->type_name);

   541 	return NULL;

   542 }

   543 

   544 void *fill_candidate_datatypes_c::visit(date_and_time_c *symbol) {

   545 	add_datatype_to_candidate_list(symbol, symbol->type_name);

   546 	return NULL;

   547 }

   603 	symbol_c *result = search_varfb_instance_type->get_basetype_decl(symbol);

   596 	add_datatype_to_candidate_list(symbol, search_varfb_instance_type->get_basetype_decl(symbol)); /* will only add if non NULL */

   604 	if (NULL != result)

   605 		add_datatype_to_candidate_list(symbol, result);

   623 	case 'X': // bit - 1 bit

   614 		case 'X': /* bit   -  1 bit  */ add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);  break;

   624 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);

   615 		case 'B': /* byte  -  8 bits */ add_datatype_to_candidate_list(symbol, &search_constant_type_c::byte_type_name);  break;

   625 		break;

   616 		case 'W': /* word  - 16 bits */ add_datatype_to_candidate_list(symbol, &search_constant_type_c::word_type_name);  break;

   626 

   617 		case 'D': /* dword - 32 bits */	add_datatype_to_candidate_list(symbol, &search_constant_type_c::dword_type_name); break;

   627 	case 'B': // byte - 8 bits

   618 		case 'L': /* lword - 64 bits */	add_datatype_to_candidate_list(symbol, &search_constant_type_c::lword_type_name); break;

   628 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::byte_type_name);

   619         	          /* if none of the above, then the empty string was used <=> boolean */

   629 		break;

   620 		default:                        add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);  break;

   630 

   631 	case 'W': // word - 16 bits

   632 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::word_type_name);

   633 		break;

   634 

   635 	case 'D': // double word - 32 bits

   636 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dword_type_name);

   637 		break;

   638 

   639 	case 'L': // long word - 64 bits

   640 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lword_type_name);

   641 		break;

   642 

   643 	default:  // if none of the above, then the empty string was used <=> boolean

   644 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);

   645 		break;

   688 	symbol_c *result = search_varfb_instance_type->get_basetype_decl(symbol);

   663 	add_datatype_to_candidate_list(symbol, search_varfb_instance_type->get_basetype_decl(symbol));  /* will only add if non NULL */

   689 	if (NULL != result) add_datatype_to_candidate_list(symbol, result);

  1133 void *fill_candidate_datatypes_c::visit(S1_operator_c *symbol) {

  1100 void *fill_candidate_datatypes_c::visit(S1_operator_c  *symbol) {handle_implicit_il_fb_call(symbol,  "S1", symbol->called_fb_declaration); return NULL;}

  1134 	handle_implicit_il_fb_call(symbol, "S1", symbol->called_fb_declaration);

  1101 void *fill_candidate_datatypes_c::visit(R1_operator_c  *symbol) {handle_implicit_il_fb_call(symbol,  "R1", symbol->called_fb_declaration); return NULL;}

  1135 	return NULL;

  1102 void *fill_candidate_datatypes_c::visit(CLK_operator_c *symbol) {handle_implicit_il_fb_call(symbol, "CLK", symbol->called_fb_declaration); return NULL;}

  1136 }

  1103 void *fill_candidate_datatypes_c::visit(CU_operator_c  *symbol) {handle_implicit_il_fb_call(symbol,  "CU", symbol->called_fb_declaration); return NULL;}

  1137 

  1104 void *fill_candidate_datatypes_c::visit(CD_operator_c  *symbol) {handle_implicit_il_fb_call(symbol,  "CD", symbol->called_fb_declaration); return NULL;}

  1138 void *fill_candidate_datatypes_c::visit(R1_operator_c *symbol) {

  1105 void *fill_candidate_datatypes_c::visit(PV_operator_c  *symbol) {handle_implicit_il_fb_call(symbol,  "PV", symbol->called_fb_declaration); return NULL;}

  1139 	handle_implicit_il_fb_call(symbol, "R1", symbol->called_fb_declaration);

  1106 void *fill_candidate_datatypes_c::visit(IN_operator_c  *symbol) {handle_implicit_il_fb_call(symbol,  "IN", symbol->called_fb_declaration); return NULL;}

  1140 	return NULL;

  1107 void *fill_candidate_datatypes_c::visit(PT_operator_c  *symbol) {handle_implicit_il_fb_call(symbol,  "PT", symbol->called_fb_declaration); return NULL;}

  1141 }

  1142 

  1143 void *fill_candidate_datatypes_c::visit(CLK_operator_c *symbol) {

  1144 	handle_implicit_il_fb_call(symbol, "CLK", symbol->called_fb_declaration);

  1145 	return NULL;

  1146 }

  1147 

  1148 void *fill_candidate_datatypes_c::visit(CU_operator_c *symbol) {

  1149 	handle_implicit_il_fb_call(symbol, "CU", symbol->called_fb_declaration);

  1150 	return NULL;

  1151 }

  1152 

  1153 void *fill_candidate_datatypes_c::visit(CD_operator_c *symbol) {

  1154 	handle_implicit_il_fb_call(symbol, "CD", symbol->called_fb_declaration);

  1155 	return NULL;

  1156 }

  1157 

  1158 void *fill_candidate_datatypes_c::visit(PV_operator_c *symbol) {

  1159 	handle_implicit_il_fb_call(symbol, "PV", symbol->called_fb_declaration);

  1160 	return NULL;

  1161 }

  1162 

  1163 void *fill_candidate_datatypes_c::visit(IN_operator_c *symbol) {

  1164 	handle_implicit_il_fb_call(symbol, "IN", symbol->called_fb_declaration);

  1165 	return NULL;

  1166 }

  1167 

  1168 void *fill_candidate_datatypes_c::visit(PT_operator_c *symbol) {

  1169 	handle_implicit_il_fb_call(symbol, "PT", symbol->called_fb_declaration);

  1170 	return NULL;

  1171 }

  1276 void *fill_candidate_datatypes_c::visit(ADD_operator_c *symbol) {

  1212 void *fill_candidate_datatypes_c::visit(ADD_operator_c *symbol) {return handle_binary_operator(widen_ADD_table, symbol, prev_il_instruction, il_operand);}

  1277 	symbol_c *prev_instruction_type, *operand_type;

  1213 void *fill_candidate_datatypes_c::visit(SUB_operator_c *symbol) {return handle_binary_operator(widen_SUB_table, symbol, prev_il_instruction, il_operand);}

  1278         

  1214 void *fill_candidate_datatypes_c::visit(MUL_operator_c *symbol) {return handle_binary_operator(widen_MUL_table, symbol, prev_il_instruction, il_operand);}

  1279         symbol->deprecated_operation = false;

  1215 void *fill_candidate_datatypes_c::visit(DIV_operator_c *symbol) {return handle_binary_operator(widen_DIV_table, symbol, prev_il_instruction, il_operand);}

  1280 	if (NULL == prev_il_instruction) return NULL;

  1216 

  1281 	for(unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {

  1282 		for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) {

  1283 			prev_instruction_type = prev_il_instruction->candidate_datatypes[i];

  1284 			operand_type = il_operand->candidate_datatypes[j];

  1285 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

  1286 			add_datatype_to_candidate_list(symbol, widening_conversion(prev_instruction_type, operand_type, widen_ADD_table));

  1287 		}

  1288 	}

  1289 	if (debug) std::cout <<  "ADD [" << prev_il_instruction->candidate_datatypes.size() << "," << il_operand->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

  1290 	return NULL;

  1291 }

  1292 

  1293 void *fill_candidate_datatypes_c::visit(SUB_operator_c *symbol) {

  1294 	symbol_c *prev_instruction_type, *operand_type;

  1295 

  1296         symbol->deprecated_operation = false;

  1297 	if (NULL == prev_il_instruction) return NULL;

  1298 	for(unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {

  1299 		for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) {

  1300 			prev_instruction_type = prev_il_instruction->candidate_datatypes[i];

  1301 			operand_type = il_operand->candidate_datatypes[j];

  1302 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

  1303 			add_datatype_to_candidate_list(symbol, widening_conversion(prev_instruction_type, operand_type, widen_SUB_table));

  1304 		}

  1305 	}

  1306 	if (debug) std::cout <<  "SUB [" << prev_il_instruction->candidate_datatypes.size() << "," << il_operand->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

  1307 	return NULL;

  1308 }

  1309 

  1310 void *fill_candidate_datatypes_c::visit(MUL_operator_c *symbol) {

  1311 	symbol_c *prev_instruction_type, *operand_type;

  1312 

  1313         symbol->deprecated_operation = false;

  1314 	if (NULL == prev_il_instruction) return NULL;

  1315 	for(unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {

  1316 		for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) {

  1317 			prev_instruction_type = prev_il_instruction->candidate_datatypes[i];

  1318 			operand_type = il_operand->candidate_datatypes[j];

  1319 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

  1320 			add_datatype_to_candidate_list(symbol, widening_conversion(prev_instruction_type, operand_type, widen_MUL_table));

  1321 		}

  1322 	}

  1323 	if (debug) std::cout <<  "MUL [" << prev_il_instruction->candidate_datatypes.size() << "," << il_operand->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

  1324 	return NULL;

  1325 }

  1326 

  1327 void *fill_candidate_datatypes_c::visit(DIV_operator_c *symbol) {

  1328 	symbol_c *prev_instruction_type, *operand_type;

  1329 

  1330         symbol->deprecated_operation = false;

  1331 	if (NULL == prev_il_instruction) return NULL;

  1332 	for(unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {

  1333 		for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) {

  1334 			prev_instruction_type = prev_il_instruction->candidate_datatypes[i];

  1335 			operand_type = il_operand->candidate_datatypes[j];

  1336 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

  1337 			add_datatype_to_candidate_list(symbol, widening_conversion(prev_instruction_type, operand_type, widen_DIV_table));

  1338 		}

  1339 	}

  1340 	if (debug) std::cout <<  "DIV [" << prev_il_instruction->candidate_datatypes.size() << "," << il_operand->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

  1341 	return NULL;

  1342 }

  1722 void *fill_candidate_datatypes_c::visit(add_expression_c *symbol) {

  1596 

  1723 	/* The following code is correct when handling the addition of 2 symbolic_variables

  1597 /* The following code is correct when handling the addition of 2 symbolic_variables

  1724 	 * In this case, adding two variables (e.g. USINT_var1 + USINT_var2) will always yield

  1598  * In this case, adding two variables (e.g. USINT_var1 + USINT_var2) will always yield

  1725 	 * the same data type, even if the result of the adition could not fit inside the same

  1599  * the same data type, even if the result of the adition could not fit inside the same

  1726 	 * data type (due to overflowing)

  1600  * data type (due to overflowing)

  1727 	 *

  1601  *

  1728 	 * However, when adding two literals (e.g. USINT#42 + USINT#3)

  1602  * However, when adding two literals (e.g. USINT#42 + USINT#3)

  1729 	 * we should be able to detect overflows of the result, and therefore not consider

  1603  * we should be able to detect overflows of the result, and therefore not consider

  1730 	 * that the result may be of type USINT.

  1604  * that the result may be of type USINT.

  1731 	 * Currently we do not yet detect these overflows, and allow handling the sum of two USINTs

  1605  * Currently we do not yet detect these overflows, and allow handling the sum of two USINTs

  1732 	 * as always resulting in an USINT, even in the following expression

  1606  * as always resulting in an USINT, even in the following expression

  1733 	 * (USINT#65535 + USINT#2).

  1607  * (USINT#65535 + USINT#2).

  1734 	 *

  1608  *

  1735 	 * In the future we can add some code to reduce

  1609  * In the future we can add some code to reduce

  1736 	 * all the expressions that are based on literals into the resulting literal

  1610  * all the expressions that are based on literals into the resulting literal

  1737 	 * value (maybe some visitor class that will run before or after data type

  1611  * value (maybe some visitor class that will run before or after data type

  1738 	 * checking). Since this class will have to be very careful to make sure it implements the same mathematical

  1612  * checking). Since this class will have to be very careful to make sure it implements the same mathematical

  1739 	 * details (e.g. how to round and truncate numbers) as defined in IEC 61131-3, we will leave this to the future.

  1613  * details (e.g. how to round and truncate numbers) as defined in IEC 61131-3, we will leave this to the future.

  1740 	 * Also, the question will arise if we should also replace calls to standard

  1614  * Also, the question will arise if we should also replace calls to standard

  1741 	 * functions if the input parameters are all literals (e.g. ADD(42, 42)). This

  1615  * functions if the input parameters are all literals (e.g. ADD(42, 42)). This

  1742 	 * means this class will be more difficult than it appears at first.

  1616  * means this class will be more difficult than it appears at first.

  1743 	 */

  1617  */

  1744 	symbol_c *left_type, *right_type;

  1618 void *fill_candidate_datatypes_c::visit(add_expression_c *symbol) {return handle_binary_expression(widen_ADD_table, symbol, symbol->l_exp, symbol->r_exp);}

  1745 

  1619 void *fill_candidate_datatypes_c::visit(sub_expression_c *symbol) {return handle_binary_expression(widen_SUB_table, symbol, symbol->l_exp, symbol->r_exp);}

  1746         symbol->deprecated_operation = false;

  1620 void *fill_candidate_datatypes_c::visit(mul_expression_c *symbol) {return handle_binary_expression(widen_MUL_table, symbol, symbol->l_exp, symbol->r_exp);}

  1747 	symbol->l_exp->accept(*this);

  1621 void *fill_candidate_datatypes_c::visit(div_expression_c *symbol) {return handle_binary_expression(widen_DIV_table, symbol, symbol->l_exp, symbol->r_exp);}

  1748 	symbol->r_exp->accept(*this);

  1749 	for(unsigned int i = 0; i < symbol->l_exp->candidate_datatypes.size(); i++) {

  1750 		for(unsigned int j = 0; j < symbol->r_exp->candidate_datatypes.size(); j++) {

  1751 			left_type = symbol->l_exp->candidate_datatypes[i];

  1752 			right_type = symbol->r_exp->candidate_datatypes[j];

  1753 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

  1754 			add_datatype_to_candidate_list(symbol, widening_conversion(left_type, right_type, widen_ADD_table));

  1755 		}

  1756 	}

  1757 	if (debug) std::cout <<  "+ [" << symbol->l_exp->candidate_datatypes.size() << "," << symbol->r_exp->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

  1758 	return NULL;

  1759 }

  1760 

  1761 

  1762 void *fill_candidate_datatypes_c::visit(sub_expression_c *symbol) {

  1763 	symbol_c *left_type, *right_type;

  1764 

  1765         symbol->deprecated_operation = false;

  1766 	symbol->l_exp->accept(*this);

  1767 	symbol->r_exp->accept(*this);

  1768 	for(unsigned int i = 0; i < symbol->l_exp->candidate_datatypes.size(); i++) {

  1769 		for(unsigned int j = 0; j < symbol->r_exp->candidate_datatypes.size(); j++) {

  1770 			left_type = symbol->l_exp->candidate_datatypes[i];

  1771 			right_type = symbol->r_exp->candidate_datatypes[j];

  1772 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

  1773 			add_datatype_to_candidate_list(symbol, widening_conversion(left_type, right_type, widen_SUB_table));

  1774 		}

  1775 	}

  1776 	if (debug) std::cout <<  "- [" << symbol->l_exp->candidate_datatypes.size() << "," << symbol->r_exp->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

  1777 	return NULL;

  1778 }

  1779 

  1780 

  1781 void *fill_candidate_datatypes_c::visit(mul_expression_c *symbol) {

  1782 	symbol_c *left_type, *right_type;

  1783 

  1784         symbol->deprecated_operation = false;

  1785 	symbol->l_exp->accept(*this);

  1786 	symbol->r_exp->accept(*this);

  1787 	for(unsigned int i = 0; i < symbol->l_exp->candidate_datatypes.size(); i++) {

  1788 		for(unsigned int j = 0; j < symbol->r_exp->candidate_datatypes.size(); j++) {

  1789 			left_type = symbol->l_exp->candidate_datatypes[i];

  1790 			right_type = symbol->r_exp->candidate_datatypes[j];

  1791 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

  1792 			add_datatype_to_candidate_list(symbol, widening_conversion(left_type, right_type, widen_MUL_table));

  1793 		}

  1794 	}

  1795 	if (debug) std::cout << "* [" << symbol->l_exp->candidate_datatypes.size() << "," << symbol->r_exp->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

  1796 

  1797 	return NULL;

  1798 }

  1799 

  1800 void *fill_candidate_datatypes_c::visit(div_expression_c *symbol) {

  1801 	symbol_c *left_type, *right_type;

  1802 

  1803         symbol->deprecated_operation = false;

  1804 	symbol->l_exp->accept(*this);

  1805 	symbol->r_exp->accept(*this);

  1806 	for(unsigned int i = 0; i < symbol->l_exp->candidate_datatypes.size(); i++) {

  1807 		for(unsigned int j = 0; j < symbol->r_exp->candidate_datatypes.size(); j++) {

  1808 			left_type = symbol->l_exp->candidate_datatypes[i];

  1809 			right_type = symbol->r_exp->candidate_datatypes[j];

  1810 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

  1811 			add_datatype_to_candidate_list(symbol, widening_conversion(left_type, right_type, widen_DIV_table));

  1812 		}

  1813 	}

  1814 	if (debug) std::cout << "/ [" << symbol->l_exp->candidate_datatypes.size() << "," << symbol->r_exp->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

  1815 	return NULL;

  1816 }