matiec: comparison stage3/narrow_candidate

equal deleted inserted replaced

-:587884880be6
+:01f6664bf8c5
 }
 /* Only set the symbol's desired datatype to 'datatype' if that datatype is in the candidate_datatype list */
 static void set_datatype(symbol_c *datatype, symbol_c *symbol) {
-	symbol->datatype = NULL;
-	if (search_in_candidate_datatype_list(datatype, symbol->candidate_datatypes) >= 0)
+	/* If we are trying to set to the undefined type, and the symbol's datatype has already been set to something else,
-		symbol->datatype = datatype;
+	 * we abort the compoiler as I don't think this should ever occur.
+	 * However, I (Mario) am not too sure of this, so if the compiler ever aborts here, please analyse the situation
+	 * carefully as it might be perfectly legal and something I have missed!
+	 */
+	if ((NULL == datatype) && (NULL != symbol->datatype)) ERROR;
+	if ((NULL == datatype) && (NULL == symbol->datatype)) return;
+	if (search_in_candidate_datatype_list(datatype, symbol->candidate_datatypes) < 0)
+		symbol->datatype = &(search_constant_type_c::invalid_type_name);
+	else {
+		if (NULL == symbol->datatype)
+			/* not yet set to anything, so we set it to the requested data type */
+			symbol->datatype = datatype;
+		else {
+			/* had already been set previously to some data type. Let's check if they are the same! */
+			if (!is_type_equal(symbol->datatype, datatype))
+				symbol->datatype = &(search_constant_type_c::invalid_type_name);
+// 			else
+				/* we leave it unchanged, as it is the same as the requested data type! */
+		}
+	}
 }
 /* Only set the symbol's desired datatype to 'datatype' if that datatype is in the candidate_datatype list */
-static void set_datatype_in_prev_il_instruction(symbol_c *datatype, il_instruction_c *symbol) {
+// static void set_datatype_in_prev_il_instructions(symbol_c *datatype, std::vector <symbol_c *> prev_il_instructions) {
+static void set_datatype_in_prev_il_instructions(symbol_c *datatype, il_instruction_c *symbol) {
+	if (NULL == symbol) ERROR;
 	for (unsigned int i = 0; i < symbol->prev_il_instruction.size(); i++)
 		set_datatype(datatype, symbol->prev_il_instruction[i]);
 }
 		set_datatype(called_fb_declaration, il_operand);
 		il_operand->accept(*this);
 	}
 	symbol_c *fb_decl = il_operand->datatype;
-	if (NULL == prev_il_instruction) {
+	if (0 == fake_prev_il_instruction->prev_il_instruction.size()) {
 		/* This IL implicit FB call (e.g. CLK ton_var) is not preceded by another IL instruction
 		 * (or list of instructions) that will set the IL current/default value.
 		 * We cannot proceed verifying type compatibility of something that does not exist.
 		 */
 		return NULL;
 	}
 	if (NULL == fb_decl) {
 		/* the il_operand is a not FB instance */
-		/* so we simply pass on the required datatype to the prev_il_instruction */
+		/* so we simply pass on the required datatype to the prev_il_instructions */
-		/* The invalid FB invocation will be caught by the print_datatypes_error_c by analysing NULL value in il_operand->datatype! */
+		/* The invalid FB invocation will be caught in the print_datatypes_error_c by analysing NULL value in il_operand->datatype! */
-		prev_il_instruction->datatype = il_instruction->datatype;
+		set_datatype_in_prev_il_instructions(il_instruction->datatype, fake_prev_il_instruction);
 		return NULL;
 	}
 	/* The value being passed to the 'param_name' parameter is actually the prev_il_instruction.
 	 * (called from the instruction_list_c for() loop that works backwards). We DO NOT want to visit it twice.
 	 * (Anyway, if we let the visit(il_fb_call_c *) recursively visit the current prev_il_instruction, this pointer
 	 * would be changed to the IL instruction coming before the current prev_il_instruction! => things would get all messed up!)
 	 * The easiest way to work around this is to simply use a new object, and copy the relevant details to that object!
 	 */
-	symbol_c param_value = *prev_il_instruction;
+printf("XX::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  fake_prev_il_instruction->candidate_datatypes.size() = %d\n",fake_prev_il_instruction->candidate_datatypes.size());
+printf("XX::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  fake_prev_il_instruction->candidate_datatypes[0] = %p\n",fake_prev_il_instruction->candidate_datatypes[0]);
+	symbol_c param_value = *fake_prev_il_instruction; /* copy the candidate_datatypes list ! */
+printf("XX::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  param_value.candidate_datatypes.size() = %d\n",param_value.candidate_datatypes.size());
+printf("XX::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  param_value.candidate_datatypes[0] = %p\n",param_value.candidate_datatypes[0]);
+printf("00::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  search_constant_type::time_type_name = %p\n", &search_constant_type_c::time_type_name);
+printf("00::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  search_constant_type::invalid_type_name = %p\n", &search_constant_type_c::invalid_type_name);
+printf("11::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  param_value.datatype = %p\n", param_value.datatype);
 	identifier_c variable_name(param_name);
 	// SYM_REF1(il_assign_operator_c, variable_name)
 	il_assign_operator_c il_assign_operator(&variable_name);
 	// SYM_REF3(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list)
 	il_param_assignment_c il_param_assignment(&il_assign_operator, &param_value/*il_operand*/, NULL);
 	il_param_list_c il_param_list;
 	il_param_list.add_element(&il_param_assignment);
 	// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list, symbol_c *called_fb_declaration)
 	CAL_operator_c CAL_operator;
 	il_fb_call_c il_fb_call(&CAL_operator, il_operand, NULL, &il_param_list);
+printf("22::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  param_value.datatype = %p\n", param_value.datatype);
 	/* A FB call does not return any datatype, but the IL instructions that come after this
 	 * FB call may require a specific datatype in the il current/default variable,
 	 * so we must pass this information up to the IL instruction before the FB call, since it will
 	 * be that IL instruction that will be required to produce the desired dtataype.
 	 * correctly set up the il_fb_call.datatype variable!
 	 */
 // 	copy_candidate_datatype_list(il_instruction/*from*/, &il_fb_call/*to*/);
 	il_fb_call.called_fb_declaration = called_fb_declaration;
 	il_fb_call.accept(*this);
+printf("33::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  param_value.datatype = %p\n", param_value.datatype);
 	/* set the required datatype of the previous IL instruction! */
 	/* NOTE:
 	 * When handling these implicit IL calls, the parameter_value being passed to the FB parameter
 	 * is actually the prev_il_instruction.
 	 * must also be used ny the IL instruction coming after this FB call.
 	 *
 	 * This means that we have two consumers/users for the same value.
 	 * We must therefore check whether the datatype required by the IL instructions following this FB call
 	 * is the same as that required for the first parameter. If not, then we have a semantic error,
-	 * and we set it to NULL.
+	 * and we set it to invalid_type_name.
 	 *
 	 * However, we only do that if:
 	 *  - The IL instruction that comes after this IL FB call actually asked this FB call for a specific
 	 *     datatype in the current/default vairable, once this IL FB call returns.
 	 *     However, sometimes, (for e.g., this FB call is the last in the IL list) the subsequent FB to not aks this
 	 *     FB call for any datatype. In that case, then the datatype required to pass to the first parameter of the
 	 *     FB call must be left unchanged!
 	 */
 	if ((NULL == il_instruction->datatype) || (is_type_equal(param_value.datatype, il_instruction->datatype))) {
-		prev_il_instruction->datatype = param_value.datatype;
+printf("44::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  param_value.datatype = %p\n", param_value.datatype);
+		set_datatype_in_prev_il_instructions(param_value.datatype, fake_prev_il_instruction);
 	} else {
-		prev_il_instruction->datatype = NULL;
+printf("55::narrow_candidate_datatypes_c::narrow_implicit_il_fb_call():  param_value.datatype = %p\n", param_value.datatype);
+		set_datatype_in_prev_il_instructions(&search_constant_type_c::invalid_type_name, fake_prev_il_instruction);
 	}
 	return NULL;
 }
 // SYM_REF2(il_instruction_c, label, il_instruction)
 // void *visit(instruction_list_c *symbol);
 void *narrow_candidate_datatypes_c::visit(il_instruction_c *symbol) {
 	if (NULL == symbol->il_instruction) {
 		/* this empty/null il_instruction cannot generate the desired datatype. We pass on the request to the previous il instruction. */
-		set_datatype_in_prev_il_instruction(symbol->datatype, symbol);
+		set_datatype_in_prev_il_instructions(symbol->datatype, symbol);
 	} else {
+		il_instruction_c tmp_prev_il_instruction(NULL, NULL);
+		/* the narrow algorithm will need access to the intersected candidate_datatype lists of all prev_il_instructions, as well as the
+		 * list of the prev_il_instructions.
+		 * Instead of creating two 'global' (within the class) variables, we create a single il_instruction_c variable (fake_prev_il_instruction),
+		 * and shove that data into this single variable.
+		 */
+		tmp_prev_il_instruction.prev_il_instruction = symbol->prev_il_instruction;
+		intersect_prev_candidate_datatype_lists(&tmp_prev_il_instruction);
 		/* Tell the il_instruction the datatype that it must generate - this was chosen by the next il_instruction (remember: we are iterating backwards!) */
-		if (symbol->prev_il_instruction.size() > 1) ERROR; /* This assertion is only valid for now. Remove it once flow_control_analysis_c is complete */
+		fake_prev_il_instruction = &tmp_prev_il_instruction;
-		if (symbol->prev_il_instruction.size() == 0)  prev_il_instruction = NULL;
+		symbol->il_instruction->datatype = symbol->datatype;
-		else                                          prev_il_instruction = symbol->prev_il_instruction[0];
 		symbol->il_instruction->accept(*this);
-		prev_il_instruction = NULL;
+		fake_prev_il_instruction = NULL;
 	}
 	return NULL;
 }
 	 *
 	 * However, if no further paramters are given, then il_operand_list will be NULL, and we will
 	 * need to create a new object to hold the pointer to prev_il_instruction.
 	 * This change will also be undone later in print_datatypes_error_c.
 	 */
-	symbol_c param_value;
+	symbol_c param_value = *fake_prev_il_instruction; /* copy the candidate_datatypes list */
 	if (NULL == symbol->il_operand_list)  symbol->il_operand_list = new il_operand_list_c;
 	if (NULL == symbol->il_operand_list)  ERROR;
-	if (NULL != prev_il_instruction)
-		param_value = *prev_il_instruction;
 	((list_c *)symbol->il_operand_list)->insert_element(&param_value, 0);
 	generic_function_call_t fcall_param = {
 		/* fcall_param.function_name               = */ symbol->function_name,
 		/* fcall_param.nonformal_operand_list      = */ symbol->il_operand_list,
 		/* fcall_param.called_function_declaration = */ symbol->called_function_declaration,
 		/* fcall_param.extensible_param_count      = */ symbol->extensible_param_count
 	};
 	narrow_function_invocation(symbol, fcall_param);
-	if (NULL != prev_il_instruction)
+	set_datatype_in_prev_il_instructions(param_value.datatype, fake_prev_il_instruction);
-		prev_il_instruction->datatype = param_value.datatype;
 	/* Undo the changes to the abstract syntax tree we made above... */
 	((list_c *)symbol->il_operand_list)->remove_element(0);
 	if (((list_c *)symbol->il_operand_list)->n == 0) {
 		/* if the list becomes empty, then that means that it did not exist before we made these changes, so we delete it! */
 il_operand = symbol->simple_instr_list; /* This is not a bug! The parenthesised expression will be used as the operator! */
 symbol->il_expr_operator->accept(*this);
 /* now give the parenthesised IL list a chance to narrow the datatypes */
 /* The datatype that is must return was set by the call symbol->il_expr_operator->accept(*this) */
-symbol_c *save_prev_il_instruction = prev_il_instruction; /*this is not really necessary, but lets play it safe */
+il_instruction_c *save_fake_prev_il_instruction = fake_prev_il_instruction; /*this is not really necessary, but lets play it safe */
 symbol->simple_instr_list->accept(*this);
-prev_il_instruction = save_prev_il_instruction;
+fake_prev_il_instruction = save_fake_prev_il_instruction;
 return NULL;
 }
 /*   il_call_operator prev_declared_fb_name
 * | il_call_operator prev_declared_fb_name '(' ')'
 }
 // SYM_REF1(il_simple_instruction_c, il_simple_instruction, symbol_c *prev_il_instruction;)
 void *narrow_candidate_datatypes_c::visit(il_simple_instruction_c *symbol)	{
-if (symbol->prev_il_instruction.size() > 1) ERROR; /* This assertion is only valid for now. Remove it once flow_control_analysis_c is complete */
+if (symbol->prev_il_instruction.size() > 1) ERROR; /* There should be no labeled insructions inside an IL expression! */
-if (symbol->prev_il_instruction.size() == 0)   prev_il_instruction = NULL;
-else                                           prev_il_instruction = symbol->prev_il_instruction[0];
+il_instruction_c tmp_prev_il_instruction(NULL, NULL);
+/* the narrow algorithm will need access to the intersected candidate_datatype lists of all prev_il_instructions, as well as the
+* list of the prev_il_instructions.
+* Instead of creating two 'global' (within the class) variables, we create a single il_instruction_c variable (fake_prev_il_instruction),
+* and shove that data into this single variable.
+*/
+if (symbol->prev_il_instruction.size() > 0)
+tmp_prev_il_instruction.candidate_datatypes = symbol->prev_il_instruction[0]->candidate_datatypes;
+tmp_prev_il_instruction.prev_il_instruction = symbol->prev_il_instruction;
+/* copy the candidate_datatypes list */
+fake_prev_il_instruction = &tmp_prev_il_instruction;
 symbol->il_simple_instruction->datatype = symbol->datatype;
 symbol->il_simple_instruction->accept(*this);
-prev_il_instruction = NULL;
+fake_prev_il_instruction = NULL;
 return NULL;
 }
 //     void *visit(il_param_list_c *symbol);
 //     void *visit(il_param_assignment_c *symbol);
 	 * NOTE 2: We do not need to call prev_il_instruction->accept(*this), as the object to which prev_il_instruction
 	 *         is pointing to will be later narrowed by the call from the for() loop of the instruction_list_c
 	 *         (or simple_instr_list_c), which iterates backwards.
 	 */
 	/* set the desired datatype of the previous il instruction */
-	prev_il_instruction->datatype = symbol->datatype;
+	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);
 	/* set the datatype for the operand */
 	il_operand->datatype = symbol->datatype;
 	il_operand->accept(*this);
 	return NULL;
 }
 	symbol->datatype = symbol->candidate_datatypes[0];
 	/* set the datatype for the operand */
 	il_operand->datatype = symbol->datatype;
 	il_operand->accept(*this);
 	/* set the desired datatype of the previous il instruction */
-	prev_il_instruction->datatype = symbol->datatype;
+	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);
-	if (debug) printf("narrow_candidate_datatypes_c::visit(ST_operator_c *symbol) returning. previous_il_instruction->datatype = %p\n", prev_il_instruction->datatype);
 	return NULL;
 }
 void *narrow_candidate_datatypes_c::visit(STN_operator_c *symbol) {
 	if (symbol->candidate_datatypes.size() != 1)
 	symbol->datatype = symbol->candidate_datatypes[0];
 	/* set the datatype for the operand */
 	il_operand->datatype = symbol->datatype;
 	il_operand->accept(*this);
 	/* set the desired datatype of the previous il instruction */
-	prev_il_instruction->datatype = symbol->datatype;
+	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);
 	return NULL;
 }
 void *narrow_candidate_datatypes_c::visit(NOT_operator_c *symbol) {
 /* TODO: ... */
 // SYM_REF0(CAL_operator_c)
 /* called from il_fb_call_c (symbol->il_call_operator->accpet(*this) ) */
 void *narrow_candidate_datatypes_c::visit(CAL_operator_c *symbol) {
 	/* set the desired datatype of the previous il instruction */
 	/* This FB call does not change the value in the current/default IL variable, so we pass the required datatype to the previous IL instruction */
-	if (NULL != prev_il_instruction)
+	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);
-		prev_il_instruction->datatype = symbol->datatype;
 	return NULL;
 }
 void *narrow_candidate_datatypes_c::narrow_conditional_flow_control_IL_instruction(symbol_c *symbol) {
 	if (symbol->candidate_datatypes.size() == 0)    symbol->datatype = NULL;
 	else    symbol->datatype = symbol->candidate_datatypes[0]; /* i.e. a bool_type_name_c! */
 	if ((NULL != symbol->datatype) && (!is_type(symbol->datatype, bool_type_name_c))) ERROR;
 	/* set the required datatype of the previous IL instruction, i.e. a bool_type_name_c! */
-	if (NULL != prev_il_instruction)    prev_il_instruction->datatype = symbol->datatype;
+	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);
 	return NULL;
 }
 // SYM_REF0(CALC_operator_c)
 	/* This RET instruction does not change the value in the current/default IL variable, so we pass the required datatype to the previous IL instruction.
 	 * Actually this should always be NULL, otherwise we have a bug in the flow_control_analysis_c
 	 * However, since that class has not yet been completely finished, we do not yet check this assertion!
 	 */
 // 	if (NULL != symbol->datatype) ERROR;
-	if (NULL != prev_il_instruction)
+	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);
-		prev_il_instruction->datatype = symbol->datatype;
 	return NULL;
 }
 void *narrow_candidate_datatypes_c::visit( RETC_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}
 void *narrow_candidate_datatypes_c::visit(RETCN_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}
 	/* This JMP instruction does not change the value in the current/default IL variable, so we pass the required datatype to the previous IL instruction.
 	 * Actually this should always be NULL, otherwise we have a bug in the flow_control_analysis_c
 	 * However, since that class has not yet been completely finished, we do not yet check this assertion!
 	 */
 // 	if (NULL != symbol->datatype) ERROR;
-	if (NULL != prev_il_instruction)
+	set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);
-		prev_il_instruction->datatype = symbol->datatype;
 	return NULL;
 }
 void *narrow_candidate_datatypes_c::visit( JMPC_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}
 void *narrow_candidate_datatypes_c::visit(JMPCN_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);}

changeset 459	01f6664bf8c5
parent 457	67d8b07bac22
child 461	fcbc0927fc96