--- a/absyntax_utils/get_datatype_info.cc Thu Oct 11 19:16:35 2012 +0100
+++ b/absyntax_utils/get_datatype_info.cc Sat Oct 13 12:13:49 2012 +0100
@@ -3,6 +3,7 @@
*
* Copyright (C) 2003-2012 Mario de Sousa (msousa@fe.up.pt)
* Copyright (C) 2007-2011 Laurent Bessard and Edouard Tisserant
+ * Copyright (C) 2012 Manuele Conti (conti.ma@alice.it)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -58,6 +59,40 @@
+
+bool get_datatype_info_c::is_type_equal(symbol_c *first_type, symbol_c *second_type) {
+ if ((NULL == first_type) || (NULL == second_type))
+ return false;
+ if (typeid(* first_type) == typeid(invalid_type_name_c))
+ return false;
+ if (typeid(*second_type) == typeid(invalid_type_name_c))
+ return false;
+
+ if (get_datatype_info_c::is_ANY_ELEMENTARY(first_type)) {
+ if (typeid(*first_type) == typeid(*second_type))
+ return true;
+ } else /* ANY_DERIVED */
+ return (first_type == second_type);
+
+ return false;
+}
+
+
+
+bool get_datatype_info_c::is_type_valid(symbol_c *type) {
+ if (NULL == type)
+ return false;
+ if (typeid(*type) == typeid(invalid_type_name_c))
+ return false;
+
+ return true;
+}
+
+
+
+
+
+
bool get_datatype_info_c::is_sfc_initstep(symbol_c *type_symbol) {
symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol);
if (typeid(*type_decl) == typeid(initial_step_c)) {return true;} /* INITIAL_STEP step_name ':' action_association_list END_STEP */ /* A pseudo data type! */
@@ -259,6 +294,7 @@
if (type_symbol == NULL) {return false;}
if (is_ANY_SAFEREAL(type_symbol)) {return true;}
if (is_ANY_SAFEINT (type_symbol)) {return true;}
+ return false;
}
@@ -287,6 +323,7 @@
if (type_symbol == NULL) {return false;}
if (is_ANY_SAFEREAL (type_symbol)) {return true;}
if (is_ANY_signed_SAFEINT(type_symbol)) {return true;}
+ return false;
}
--- a/absyntax_utils/get_datatype_info.hh Thu Oct 11 19:16:35 2012 +0100
+++ b/absyntax_utils/get_datatype_info.hh Sat Oct 13 12:13:49 2012 +0100
@@ -57,6 +57,9 @@
public:
+ static bool is_type_equal(symbol_c *first_type, symbol_c *second_type);
+ static bool is_type_valid(symbol_c *type);
+
static bool is_ANY_REAL_literal(symbol_c *type_symbol); /* Can't we do away with this?? */
static bool is_ANY_INT_literal (symbol_c *type_symbol); /* Can't we do away with this?? */
--- a/stage3/datatype_functions.cc Thu Oct 11 19:16:35 2012 +0100
+++ b/stage3/datatype_functions.cc Sat Oct 13 12:13:49 2012 +0100
@@ -403,7 +403,7 @@
return -1;
for(unsigned int i = 0; i < candidate_datatypes.size(); i++)
- if (is_type_equal(datatype, candidate_datatypes[i]))
+ if (get_datatype_info_c::is_type_equal(datatype, candidate_datatypes[i]))
return i;
/* Not found ! */
return -1;
@@ -464,30 +464,3 @@
-bool is_type_equal(symbol_c *first_type, symbol_c *second_type) {
- if ((NULL == first_type) || (NULL == second_type))
- return false;
- if (typeid(* first_type) == typeid(invalid_type_name_c))
- return false;
- if (typeid(*second_type) == typeid(invalid_type_name_c))
- return false;
-
- if (get_datatype_info_c::is_ANY_ELEMENTARY(first_type)) {
- if (typeid(*first_type) == typeid(*second_type))
- return true;
- } else /* ANY_DERIVED */
- return (first_type == second_type);
-
- return false;
-}
-
-
-
-bool is_type_valid(symbol_c *type) {
- if (NULL == type)
- return false;
- if (typeid(*type) == typeid(invalid_type_name_c))
- return false;
-
- return true;
-}
--- a/stage3/datatype_functions.hh Thu Oct 11 19:16:35 2012 +0100
+++ b/stage3/datatype_functions.hh Sat Oct 13 12:13:49 2012 +0100
@@ -163,10 +163,4 @@
-bool is_type_equal(symbol_c *first_type, symbol_c *second_type);
-bool is_type_valid(symbol_c *type);
-
-
-
-
#endif /* _HELPER_FUNCTIONS_HH_ */
--- a/stage3/declaration_check.cc Thu Oct 11 19:16:35 2012 +0100
+++ b/stage3/declaration_check.cc Sat Oct 13 12:13:49 2012 +0100
@@ -111,7 +111,7 @@
/* For the moment, we will just use search_base_type_c instead... */
symbol_c *glo_type = search_base_type.get_basetype_decl(glo_decl);
symbol_c *ext_type = search_base_type.get_basetype_decl(ext_decl);
- if (! is_type_equal(glo_type, ext_type))
+ if (! get_datatype_info_c::is_type_equal(glo_type, ext_type))
STAGE3_ERROR(0, ext_decl, ext_decl, "Declaration error an external redefinition data type.");
}
}
--- a/stage3/fill_candidate_datatypes.cc Thu Oct 11 19:16:35 2012 +0100
+++ b/stage3/fill_candidate_datatypes.cc Sat Oct 13 12:13:49 2012 +0100
@@ -96,7 +96,7 @@
/* If it is an invalid data type, do not insert!
* NOTE: it reduces overall code size to do this test here, instead of doing every time before calling the add_datatype_to_candidate_list() function.
*/
- if (!is_type_valid(datatype)) /* checks for NULL and invalid_type_name_c */
+ if (!get_datatype_info_c::is_type_valid(datatype)) /* checks for NULL and invalid_type_name_c */
return false;
if (search_in_candidate_datatype_list(datatype, symbol->candidate_datatypes) >= 0)
@@ -612,7 +612,7 @@
for (unsigned int u = 0; u < symbol->upper_limit->candidate_datatypes.size(); u++) {
for(unsigned int l = 0; l < symbol->lower_limit->candidate_datatypes.size(); l++) {
- if (is_type_equal(symbol->upper_limit->candidate_datatypes[u], symbol->lower_limit->candidate_datatypes[l]))
+ if (get_datatype_info_c::is_type_equal(symbol->upper_limit->candidate_datatypes[u], symbol->lower_limit->candidate_datatypes[l]))
add_datatype_to_candidate_list(symbol, symbol->lower_limit->candidate_datatypes[l]);
}
}
@@ -1190,7 +1190,7 @@
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];
- if (is_type_equal(prev_instruction_type, operand_type))
+ if (get_datatype_info_c::is_type_equal(prev_instruction_type, operand_type))
add_datatype_to_candidate_list(symbol, prev_instruction_type);
}
}
@@ -1206,7 +1206,7 @@
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];
- if (is_type_equal(prev_instruction_type,operand_type) && get_datatype_info_c::is_ANY_BIT_compatible(operand_type))
+ if (get_datatype_info_c::is_type_equal(prev_instruction_type,operand_type) && get_datatype_info_c::is_ANY_BIT_compatible(operand_type))
add_datatype_to_candidate_list(symbol, prev_instruction_type);
}
}
@@ -1244,7 +1244,7 @@
* 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 (is_type_equal(prev_instruction_type,operand_type) && get_datatype_info_c::is_BOOL_compatible(operand_type))
+ 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);
}
}
@@ -1266,7 +1266,7 @@
* 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 (is_type_equal(prev_instruction_type,operand_type) && get_datatype_info_c::is_BOOL_compatible(operand_type))
+ 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);
}
}
@@ -1458,7 +1458,7 @@
for(unsigned int j = 0; j < symbol->r_exp->candidate_datatypes.size(); j++) {
left_type = symbol->l_exp->candidate_datatypes[i];
right_type = symbol->r_exp->candidate_datatypes[j];
- if (is_type_equal(left_type, right_type))
+ if (get_datatype_info_c::is_type_equal(left_type, right_type))
add_datatype_to_candidate_list(symbol, left_type);
}
}
--- a/stage3/narrow_candidate_datatypes.cc Thu Oct 11 19:16:35 2012 +0100
+++ b/stage3/narrow_candidate_datatypes.cc Sat Oct 13 12:13:49 2012 +0100
@@ -96,7 +96,7 @@
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))
+ if (!get_datatype_info_c::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! */
@@ -273,7 +273,7 @@
/* set the called_function_declaration taking into account the datatype that we need to return */
for(unsigned int i = 0; i < fcall->candidate_datatypes.size(); i++) {
- if (is_type_equal(fcall->candidate_datatypes[i], fcall->datatype)) {
+ if (get_datatype_info_c::is_type_equal(fcall->candidate_datatypes[i], fcall->datatype)) {
fcall_data.called_function_declaration = fcall_data.candidate_functions[i];
break;
}
@@ -398,7 +398,7 @@
* 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))) {
+ if ((NULL == il_instruction->datatype) || (get_datatype_info_c::is_type_equal(param_value.datatype, il_instruction->datatype))) {
set_datatype_in_prev_il_instructions(param_value.datatype, fake_prev_il_instruction);
} else {
set_datatype_in_prev_il_instructions(&search_constant_type_c::invalid_type_name, fake_prev_il_instruction);
@@ -1096,7 +1096,7 @@
}
}
// if (count > 1) ERROR; /* Since we also support SAFE data types, this assertion is not necessarily always tru! */
- if (is_type_valid(symbol->datatype) && (count <= 0)) ERROR;
+ if (get_datatype_info_c::is_type_valid(symbol->datatype) && (count <= 0)) ERROR;
l_expr->accept(*this);
r_expr->accept(*this);
@@ -1278,7 +1278,7 @@
void *narrow_candidate_datatypes_c::visit(case_list_c *symbol) {
for (int i = 0; i < symbol->n; i++) {
for (unsigned int k = 0; k < symbol->elements[i]->candidate_datatypes.size(); k++) {
- if (is_type_equal(symbol->datatype, symbol->elements[i]->candidate_datatypes[k]))
+ if (get_datatype_info_c::is_type_equal(symbol->datatype, symbol->elements[i]->candidate_datatypes[k]))
symbol->elements[i]->datatype = symbol->elements[i]->candidate_datatypes[k];
}
/* NOTE: this may be an integer, a subrange_c, or a enumerated value! */
@@ -1301,7 +1301,7 @@
symbol->control_variable->accept(*this);
/* BEG expression */
for(unsigned int i = 0; i < symbol->beg_expression->candidate_datatypes.size(); i++) {
- if (is_type_equal(symbol->control_variable->datatype,symbol->beg_expression->candidate_datatypes[i]) &&
+ if (get_datatype_info_c::is_type_equal(symbol->control_variable->datatype,symbol->beg_expression->candidate_datatypes[i]) &&
get_datatype_info_c::is_ANY_INT(symbol->beg_expression->candidate_datatypes[i])) {
symbol->beg_expression->datatype = symbol->beg_expression->candidate_datatypes[i];
}
@@ -1309,7 +1309,7 @@
symbol->beg_expression->accept(*this);
/* END expression */
for(unsigned int i = 0; i < symbol->end_expression->candidate_datatypes.size(); i++) {
- if (is_type_equal(symbol->control_variable->datatype,symbol->end_expression->candidate_datatypes[i]) &&
+ if (get_datatype_info_c::is_type_equal(symbol->control_variable->datatype,symbol->end_expression->candidate_datatypes[i]) &&
get_datatype_info_c::is_ANY_INT(symbol->end_expression->candidate_datatypes[i])) {
symbol->end_expression->datatype = symbol->end_expression->candidate_datatypes[i];
}
@@ -1318,7 +1318,7 @@
/* BY expression */
if (NULL != symbol->by_expression) {
for(unsigned int i = 0; i < symbol->by_expression->candidate_datatypes.size(); i++) {
- if (is_type_equal(symbol->control_variable->datatype,symbol->by_expression->candidate_datatypes[i]) &&
+ if (get_datatype_info_c::is_type_equal(symbol->control_variable->datatype,symbol->by_expression->candidate_datatypes[i]) &&
get_datatype_info_c::is_ANY_INT(symbol->by_expression->candidate_datatypes[i])) {
symbol->by_expression->datatype = symbol->by_expression->candidate_datatypes[i];
}
--- a/stage3/print_datatypes_error.cc Thu Oct 11 19:16:35 2012 +0100
+++ b/stage3/print_datatypes_error.cc Sat Oct 13 12:13:49 2012 +0100
@@ -109,10 +109,10 @@
bool res;
if (symbol->prev_il_instruction.size() > 0)
- res = is_type_valid(symbol->prev_il_instruction[0]->datatype);
+ res = get_datatype_info_c::is_type_valid(symbol->prev_il_instruction[0]->datatype);
for (unsigned int i = 1; i < symbol->prev_il_instruction.size(); i++)
- res &= is_type_equal(symbol->prev_il_instruction[i-1]->datatype, symbol->prev_il_instruction[i]->datatype);
+ res &= get_datatype_info_c::is_type_equal(symbol->prev_il_instruction[i-1]->datatype, symbol->prev_il_instruction[i]->datatype);
return res;
}
@@ -250,14 +250,14 @@
*/
for (unsigned int p = 0; p < il_instruction_symbol->prev_il_instruction.size(); p++) {
symbol_c *value = il_instruction_symbol->prev_il_instruction[p];
- if (!is_type_valid(value->datatype)) {
+ if (!get_datatype_info_c::is_type_valid(value->datatype)) {
function_invocation_error = true;
STAGE3_ERROR(0, fcall, fcall, "Data type incompatibility for value passed to first parameter when invoking function '%s'", ((identifier_c *)fcall_data.function_name)->value);
STAGE3_ERROR(0, value, value, "This is the IL instruction producing the incompatible data type to first parameter of function '%s'", ((identifier_c *)fcall_data.function_name)->value);
}
}
#else
- if (!is_type_valid(il_instruction_symbol->datatype)) {
+ if (!get_datatype_info_c::is_type_valid(il_instruction_symbol->datatype)) {
function_invocation_error = true;
STAGE3_ERROR(0, fcall, fcall, "Data type incompatibility between value in IL 'accumulator' and first parameter of function '%s'", ((identifier_c *)fcall_data.function_name)->value);
}
@@ -266,7 +266,7 @@
/* when handling a IL function call, and an error is found in the first parameter, then we bug out and do not print out any more error messages. */
return;
}
- else if (!is_type_valid(param_value->datatype)) {
+ else if (!get_datatype_info_c::is_type_valid(param_value->datatype)) {
function_invocation_error = true;
STAGE3_ERROR(0, param_value, param_value, "Data type incompatibility for value passed in position %d when invoking %s '%s'", i, POU_str, ((identifier_c *)fcall_data.function_name)->value);
}
@@ -537,12 +537,12 @@
/* B 1.3.3 - Derived data types */
/********************************/
void *print_datatypes_error_c::visit(simple_spec_init_c *symbol) {
- if (!is_type_valid(symbol->simple_specification->datatype)) {
+ if (!get_datatype_info_c::is_type_valid(symbol->simple_specification->datatype)) {
STAGE3_ERROR(0, symbol->simple_specification, symbol->simple_specification, "Invalid data type.");
} else if (NULL != symbol->constant) {
- if (!is_type_valid(symbol->constant->datatype))
+ if (!get_datatype_info_c::is_type_valid(symbol->constant->datatype))
STAGE3_ERROR(0, symbol->constant, symbol->constant, "Initial value has incompatible data type.");
- } else if (!is_type_valid(symbol->datatype)) {
+ } else if (!get_datatype_info_c::is_type_valid(symbol->datatype)) {
ERROR; /* If we have an error here, then we must also have an error in one of
* the two previous tests. If we reach this point, some strange error is ocurring!
*/
@@ -577,7 +577,7 @@
/********************************************/
void *print_datatypes_error_c::visit(direct_variable_c *symbol) {
if (symbol->candidate_datatypes.size() == 0) ERROR;
- if (!is_type_valid(symbol->datatype))
+ if (!get_datatype_info_c::is_type_valid(symbol->datatype))
STAGE3_ERROR(4, symbol, symbol, "Direct variable has incompatible data type with expression.");
return NULL;
}
@@ -648,7 +648,7 @@
symbol->located_var_spec_init->accept(*this);
/* It does not make sense to call symbol->location->accept(*this). The check is done right here if the following if() */
// symbol->location->accept(*this);
- if ((is_type_valid(symbol->located_var_spec_init->datatype)) && (!is_type_valid(symbol->location->datatype)))
+ if ((get_datatype_info_c::is_type_valid(symbol->located_var_spec_init->datatype)) && (!get_datatype_info_c::is_type_valid(symbol->location->datatype)))
STAGE3_ERROR(0, symbol, symbol, "Bit size of data type is incompatible with bit size of location.");
return NULL;
}
@@ -1264,7 +1264,7 @@
void *print_datatypes_error_c::visit(while_statement_c *symbol) {
symbol->expression->accept(*this);
- if (!is_type_valid(symbol->expression->datatype)) {
+ if (!get_datatype_info_c::is_type_valid(symbol->expression->datatype)) {
STAGE3_ERROR(0, symbol, symbol, "Invalid data type for 'WHILE' condition.");
return NULL;
}
@@ -1274,7 +1274,7 @@
}
void *print_datatypes_error_c::visit(repeat_statement_c *symbol) {
- if (!is_type_valid(symbol->expression->datatype)) {
+ if (!get_datatype_info_c::is_type_valid(symbol->expression->datatype)) {
STAGE3_ERROR(0, symbol, symbol, "Invalid data type for 'REPEAT' condition.");
return NULL;
}