325 		/* only set it if it is in the candidate datatypes list! */  

   325 		set_datatype(called_fb_declaration, il_operand); /* only set it if it is in the candidate datatypes list! */  

   326 		set_datatype(called_fb_declaration, il_operand);

   340 		/* the il_operand is a not FB instance */

   340 		/* the il_operand is a not FB instance, or it simply does not even exist, */

   652 

   652 // SYM_REF1(symbolic_variable_c, var_name)

   653 void *narrow_candidate_datatypes_c::visit(symbolic_variable_c *symbol) {

   654 	symbol->var_name->datatype = symbol->datatype;

   655 	return NULL;

   656 }

   958 /* 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 */

  1006 /* NOTE: The parameter 'called_fb_declaration'is used to pass data between stage 3 and stage4 */

  1052 	/* NOTE 1: the il_operand __may__ be pointing to a parenthesized list of IL instructions. 

  1146 	if (NULL == il_operand) return NULL; /* if no IL operand => error in the source code!! */

  1147 

  1148 	 /* NOTE 1: the il_operand __may__ be pointing to a parenthesized list of IL instructions. 

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

  1163 	if (NULL != symbol->datatype) { // next IL instructions were able to determine the datatype this instruction should produce

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

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

  1069 			prev_instruction_type = fake_prev_il_instruction->candidate_datatypes[i];

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

  1070 			operand_type = il_operand->candidate_datatypes[j];

  1166 				prev_instruction_type = fake_prev_il_instruction->candidate_datatypes[i];

  1071 			if (is_widening_compatible(widen_table, prev_instruction_type, operand_type, symbol->datatype, deprecated_operation)) {

  1167 				operand_type = il_operand->candidate_datatypes[j];

  1072 				/* set the desired datatype of the previous il instruction */

  1168 				if (is_widening_compatible(widen_table, prev_instruction_type, operand_type, symbol->datatype, deprecated_operation)) {

  1073 				set_datatype_in_prev_il_instructions(prev_instruction_type, fake_prev_il_instruction);

  1169 					/* set the desired datatype of the previous il instruction */

  1074 				/* set the datatype for the operand */

  1170 					set_datatype_in_prev_il_instructions(prev_instruction_type, fake_prev_il_instruction);

  1075 				il_operand->datatype = operand_type;

  1171 					/* set the datatype for the operand */

  1076 				il_operand->accept(*this);

  1172 					set_il_operand_datatype(il_operand, operand_type);

  1077 				

  1173 					

  1078 				/* NOTE: DO NOT search any further! Return immediately!

  1174 					/* NOTE: DO NOT search any further! Return immediately!

  1079 				 * Since we support SAFE*** datatypes, multiple entries in the widen_table may be compatible.

  1175 					 * Since we support SAFE*** datatypes, multiple entries in the widen_table may be compatible.

  1080 				 * If we try to set more than one distinct datatype on the same symbol, then the datatype will be set to

  1176 					 * If we try to set more than one distinct datatype on the same symbol, then the datatype will be set to

  1081 				 * an invalid_datatype, which is NOT what we want!

  1177 					 * an invalid_datatype, which is NOT what we want!

  1082 				 */

  1178 					 */

  1083 				return NULL;

  1179 					return NULL;

  1180 				}

  1087 	return NULL;

  1184 	/* We were not able to determine the required datatype, but we still give the il_operand a chance to be narrowed! */

  1088 }

  1185 	set_il_operand_datatype(il_operand, NULL);

  1089 

  1186 	return NULL;

  1090 

  1187 }

  1091 

  1188 

  1092 

  1189 

  1093 

  1190 

  1094 void *narrow_candidate_datatypes_c::handle_il_instruction(symbol_c *symbol) {

  1191 

  1095 	if (NULL == symbol->datatype)

  1192 /* Narrow IL operators whose execution is conditional on the boolean value in the accumulator.

  1096 		/* next IL instructions were unable to determine the datatype this instruction should produce */

  1193  * Basically, narrow the JMPC, JMPCN, RETC, RETCN, CALC, and CALCN operators!

  1097 		return NULL;

  1194  * Also does part of the S and R operator narrowing!!!

  1098 	/* NOTE 1: the il_operand __may__ be pointing to a parenthesized list of IL instructions. 

  1195  */

  1099 	 * e.g.  LD 33

  1196 void *narrow_candidate_datatypes_c::narrow_conditional_operator(symbol_c *symbol) {

  1100 	 *       AND ( 45

  1197 	/* if the next IL instructions needs us to provide a datatype other than a BOOL or a SAFEBOOL, 

  1101 	 *            OR 56

  1198 	 * then we have an internal compiler error - most likely in fill_candidate_datatypes_c 

  1102 	 *            )

  1199 	 */

  1103 	 *       When we handle the first 'AND' IL_operator, the il_operand will point to an simple_instr_list_c.

  1200 	// I (mario) am confident the fill/narrow algorithms are working correctly, so for now we can disable the assertions!

  1104 	 *       In this case, when we call il_operand->accept(*this);, the prev_il_instruction pointer will be overwritten!

  1201 	//if ((NULL != symbol->datatype) && (!get_datatype_info_c::is_BOOL_compatible(symbol->datatype))) ERROR;

  1105 	 *

  1202 	//if (symbol->candidate_datatypes.size() > 2) ERROR; /* may contain, at most, a BOOL and a SAFEBOOL */

  1106 	 *       We must therefore set the prev_il_instruction->datatype = symbol->datatype;

  1203 

  1107 	 *       __before__ calling il_operand->accept(*this) !!

  1204 	/* NOTE: If there is no IL instruction following this S, R, CALC, CALCN, JMPC, JMPCN, RETC, or RETCN instruction,

  1108 	 *

  1205 	 *       we must still provide a bool_type_name_c datatype (if possible, i.e. if it exists in the candidate datatype list).

  1109 	 * NOTE 2: We do not need to call prev_il_instruction->accept(*this), as the object to which prev_il_instruction

  1206 	 *       If it is not possible, we set it to NULL

  1110 	 *         is pointing to will be later narrowed by the call from the for() loop of the instruction_list_c

  1207 	 * 

  1111 	 *         (or simple_instr_list_c), which iterates backwards.

  1208 	 * NOTE: Note that this algorithm we are implementing is slightly wrong. 

  1112 	 */

  1209 	 *        (a) It ignores that a SAFEBOOL may be needed instead of a BOOL datatype. 

  1113 	/* set the desired datatype of the previous il instruction */

  1210 	 *        (b) It also ignores that this method gets to be called twice on the same 

  1211 	 *            object (the narrow algorithm runs through the IL list twice in order to

  1212 	 *            handle forward JMPs), so the assumption that we must immediately set our

  1213 	 *            own datatype if we get called with a NULL symbol->datatype is incorrect 

  1214 	 *           (it may be that the second time it is called it will be with the correct datatype!).

  1215 	 * 

  1216 	 *       These two issues (a) and (b) together means that we should only really be setting our own

  1217 	 *       datatype if we are certain that the following IL instructions will never set it for us

  1218 	 *       - basically if the following IL instruction is a LD, or a JMP to a LD, or a JMP to a JMP to a LD,

  1219 	 *        etc..., or a conditional JMP whose both branches go to LD, etc...!!!

  1220 	 *       

  1221 	 *       At the moment, it seems to me that we would need to write a visitor class to do this for us!

  1222 	 *       I currently have other things on my mind at the moment, so I will leave this for later...

  1223 	 *       For the moment we just set it to BOOL, and ignore the support of SAFEBOOL!

  1224 	 */

  1225 	if (NULL == symbol->datatype) set_datatype(&get_datatype_info_c::bool_type_name /* datatype*/, symbol /* symbol */);

  1226 	if (NULL == symbol->datatype) ERROR; // the BOOL is not on the candidate_datatypes! Strange... Probably a bug in fill_candidate_datatype_c

  1227 

  1228 	/* set the required datatype of the previous IL instruction, i.e. a bool_type_name_c! */

  1115 	  

  1230 	return NULL;

  1231 }

  1232 

  1233 

  1234 

  1235 void *narrow_candidate_datatypes_c::narrow_S_and_R_operator(symbol_c *symbol, const char *param_name, symbol_c *called_fb_declaration) {

  1236 	if (NULL != called_fb_declaration) 

  1237 	  /* FB call semantics */  

  1238 	  return narrow_implicit_il_fb_call(symbol, param_name, called_fb_declaration); 

  1239 	

  1240 	/* Set/Reset semantics */  

  1241 	narrow_conditional_operator(symbol);

  1242 	/* set the datatype for the il_operand */

  1243 	if ((NULL != il_operand) && (il_operand->candidate_datatypes.size() > 0))

  1244 		set_il_operand_datatype(il_operand, il_operand->candidate_datatypes[0]);

  1245 	return NULL;

  1246 }

  1247 

  1248 

  1249 

  1250 void *narrow_candidate_datatypes_c::narrow_store_operator(symbol_c *symbol) {

  1251 	if (symbol->candidate_datatypes.size() == 1) {

  1252 		symbol->datatype = symbol->candidate_datatypes[0];

  1253 		/* set the desired datatype of the previous il instruction */

  1254 		set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);

  1255 		/* In the case of the ST operator, we must set the datatype of the il_instruction_c object that points to this ST_operator_c ourselves,

  1256 		 * since the following il_instruction_c objects have not done it, as is normal/standard for other instructions!

  1257 		 */

  1258 		current_il_instruction->datatype = symbol->datatype;

  1259 	}

  1260 	

  1117 	il_operand->datatype = symbol->datatype;

  1262 	set_il_operand_datatype(il_operand, symbol->datatype);

  1118 	il_operand->accept(*this);

  1263 	return NULL;

  1119 	return NULL;

  1264 }

  1120 }

  1265 

  1121 

  1266 

  1122 

  1267 

  1123 

  1268 void *narrow_candidate_datatypes_c::visit(  LD_operator_c *symbol)  {return set_il_operand_datatype(il_operand, symbol->datatype);}

  1124 

  1269 void *narrow_candidate_datatypes_c::visit( LDN_operator_c *symbol)  {return set_il_operand_datatype(il_operand, symbol->datatype);}

  1125 void *narrow_candidate_datatypes_c::visit(LD_operator_c *symbol)   {

  1270 

  1126 	if (NULL == symbol->datatype)

  1271 void *narrow_candidate_datatypes_c::visit(  ST_operator_c *symbol)  {return narrow_store_operator(symbol);}

  1127 		/* next IL instructions were unable to determine the datatype this instruction should produce */

  1272 void *narrow_candidate_datatypes_c::visit( STN_operator_c *symbol)  {return narrow_store_operator(symbol);}

  1128 		return NULL;

  1273 

  1129 	/* set the datatype for the operand */

  1274 

  1130 	il_operand->datatype = symbol->datatype;

  1275 /* NOTE: the standard allows syntax in which the NOT operator is followed by an optional <il_operand>

  1131 	il_operand->accept(*this);

  1276  *              NOT [<il_operand>]

  1132 	return NULL;

  1277  *       However, it does not define the semantic of the NOT operation when the <il_operand> is specified.

  1133 }

  1278  *       We therefore consider it an error if an il_operand is specified!

  1134 

  1279  *       This error will be detected in print_datatypes_error_c!!

  1135 

  1280  */

  1136 void *narrow_candidate_datatypes_c::visit(LDN_operator_c *symbol)  {

  1281 /* This operator does not change the data type, it simply inverts the bits in the ANT_BIT data types! */

  1137 	if (NULL == symbol->datatype)

  1282 /* So, we merely set the desired datatype of the previous il instruction */

  1138 		/* next IL instructions were unable to determine the datatype this instruction should produce */

  1283 void *narrow_candidate_datatypes_c::visit( NOT_operator_c *symbol)  {set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);return NULL;}

  1139 		return NULL;

  1284 

  1140 	/* set the datatype for the operand */

  1285 void *narrow_candidate_datatypes_c::visit(   S_operator_c *symbol)  {return narrow_S_and_R_operator   (symbol, "S",   symbol->called_fb_declaration);}

  1141 	il_operand->datatype = symbol->datatype;

  1286 void *narrow_candidate_datatypes_c::visit(   R_operator_c *symbol)  {return narrow_S_and_R_operator   (symbol, "R",   symbol->called_fb_declaration);}

  1142 	il_operand->accept(*this);

  1143 	return NULL;

  1144 }

  1145 

  1146 void *narrow_candidate_datatypes_c::visit(ST_operator_c *symbol) {

  1147 	if (symbol->candidate_datatypes.size() != 1)

  1148 		return NULL;

  1149 	symbol->datatype = symbol->candidate_datatypes[0];

  1150 	/* set the datatype for the operand */

  1151 	il_operand->datatype = symbol->datatype;

  1152 	il_operand->accept(*this);

  1153 	/* set the desired datatype of the previous il instruction */

  1154 	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);

  1155 	/* In the case of the ST operator, we must set the datatype of the il_instruction_c object that points to this ST_operator_c ourselves,

  1156 	 * since the following il_instruction_c objects have not done it, as is normal/standard for other instructions!

  1157 	 */

  1158 	current_il_instruction->datatype = symbol->datatype;

  1159 	return NULL;

  1160 }

  1161 

  1162 void *narrow_candidate_datatypes_c::visit(STN_operator_c *symbol) {

  1163 	if (symbol->candidate_datatypes.size() != 1)

  1164 		return NULL;

  1165 	symbol->datatype = symbol->candidate_datatypes[0];

  1166 	/* set the datatype for the operand */

  1167 	il_operand->datatype = symbol->datatype;

  1168 	il_operand->accept(*this);

  1169 	/* set the desired datatype of the previous il instruction */

  1170 	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);

  1171 	return NULL;

  1172 }

  1173 

  1174 void *narrow_candidate_datatypes_c::visit(NOT_operator_c *symbol) {

  1175 	/* NOTE: the standard allows syntax in which the NOT operator is followed by an optional <il_operand>

  1176 	 *              NOT [<il_operand>]

  1177 	 *       However, it does not define the semantic of the NOT operation when the <il_operand> is specified.

  1178 	 *       We therefore consider it an error if an il_operand is specified!

  1179 	 */

  1180 	/* We do not change the data type, we simply invert the bits in bit types! */

  1181 	/* So, we set the desired datatype of the previous il instruction */

  1182 	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);

  1183 	return NULL;

  1184 }

  1185 

  1186 void *narrow_candidate_datatypes_c::visit(S_operator_c *symbol)  {

  1187   /* TODO: what if this is a FB call? */

  1188 	return handle_il_instruction(symbol);

  1189 }

  1190 void *narrow_candidate_datatypes_c::visit(R_operator_c *symbol)  {

  1191   /* TODO: what if this is a FB call? */

  1192 	return handle_il_instruction(symbol);

  1193 }

  1194 

  1224 

  1316 /* visitors to CAL_operator_c, CALC_operator_c and CALCN_operator_c are called from visit(il_fb_call_c *) {symbol->il_call_operator->accept(*this)} */

  1225 

  1226 void *narrow_candidate_datatypes_c::narrow_conditional_flow_control_IL_instruction(symbol_c *symbol) {

  1227 	/* if the next IL instructions needs us to provide a datatype other than a bool, 

  1228 	 * then we have an internal compiler error - most likely in fill_candidate_datatypes_c 

  1229 	 */

  1230 	if ((NULL != symbol->datatype) && (!get_datatype_info_c::is_BOOL_compatible(symbol->datatype))) ERROR;

  1231 	if (symbol->candidate_datatypes.size() > 1) ERROR;

  1232 

  1233 	/* NOTE: If there is no IL instruction following this CALC, CALCN, JMPC, JMPC, ..., instruction,

  1234 	 *       we must still provide a bool_type_name_c datatype (if possible, i.e. if it exists in the candidate datatype list).

  1235 	 *       If it is not possible, we set it to NULL

  1236 	 */

  1237 	if (symbol->candidate_datatypes.size() == 0)    symbol->datatype = NULL;

  1238 	else    symbol->datatype = symbol->candidate_datatypes[0]; /* i.e. a bool_type_name_c! */

  1239 	if ((NULL != symbol->datatype) && (!get_datatype_info_c::is_BOOL_compatible(symbol->datatype))) ERROR;

  1240 

  1241 	/* set the required datatype of the previous IL instruction, i.e. a bool_type_name_c! */

  1242 	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);

  1243 	return NULL;

  1244 }

  1245 

  1246 

  1247 // SYM_REF0(CAL_operator_c)

  1248 // SYM_REF0(CALC_operator_c)

  1249 // SYM_REF0(CALCN_operator_c)

  1250 /* called from visit(il_fb_call_c *) {symbol->il_call_operator->accpet(*this)} */

  1256 void *narrow_candidate_datatypes_c::visit( CALC_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}

  1321 void *narrow_candidate_datatypes_c::visit( CALC_operator_c *symbol) {return narrow_conditional_operator(symbol);}

  1257 void *narrow_candidate_datatypes_c::visit(CALCN_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}

  1322 void *narrow_candidate_datatypes_c::visit(CALCN_operator_c *symbol) {return narrow_conditional_operator(symbol);}

  1258 void *narrow_candidate_datatypes_c::visit( RETC_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}

  1323 void *narrow_candidate_datatypes_c::visit( RETC_operator_c *symbol) {return narrow_conditional_operator(symbol);}

  1259 void *narrow_candidate_datatypes_c::visit(RETCN_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}

  1324 void *narrow_candidate_datatypes_c::visit(RETCN_operator_c *symbol) {return narrow_conditional_operator(symbol);}

  1260 void *narrow_candidate_datatypes_c::visit( JMPC_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}

  1325 void *narrow_candidate_datatypes_c::visit( JMPC_operator_c *symbol) {return narrow_conditional_operator(symbol);}

  1261 void *narrow_candidate_datatypes_c::visit(JMPCN_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}

  1326 void *narrow_candidate_datatypes_c::visit(JMPCN_operator_c *symbol) {return narrow_conditional_operator(symbol);}