Correctly identify errors when parsing erroneous code (make sure flex goes back to INITIAL state when code contains errors that do not allow determining whether ST or IL is being parsed)
/*
* matiec - a compiler for the programming languages defined in IEC 61131-3
*
* Copyright (C) 2009-2012 Mario de Sousa (msousa@fe.up.pt)
* 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
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*
* This code is made available on the understanding that it will not be
* used in safety-critical situations without a full and competent review.
*/
/*
* An IEC 61131-3 compiler.
*
* Based on the
* FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)
*
*/
/* Expressions on the left hand side of assignment statements have aditional restrictions on their datatype.
* For example, they cannot be literals, CONSTANT type variables, function invocations, etc...
* This class wil do those checks.
*
* Note that assignment may also be done when passing variables to OUTPUT or IN_OUT function parameters,so we check those too.
*/
#include "lvalue_check.hh"
#define FIRST_(symbol1, symbol2) (((symbol1)->first_order < (symbol2)->first_order) ? (symbol1) : (symbol2))
#define LAST_(symbol1, symbol2) (((symbol1)->last_order > (symbol2)->last_order) ? (symbol1) : (symbol2))
#define STAGE3_ERROR(error_level, symbol1, symbol2, ...) { \
if (current_display_error_level >= error_level) { \
fprintf(stderr, "%s:%d-%d..%d-%d: error: ", \
FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\
LAST_(symbol1,symbol2) ->last_line, LAST_(symbol1,symbol2) ->last_column);\
fprintf(stderr, __VA_ARGS__); \
fprintf(stderr, "\n"); \
error_count++; \
} \
}
#define STAGE3_WARNING(symbol1, symbol2, ...) { \
fprintf(stderr, "%s:%d-%d..%d-%d: warning: ", \
FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\
LAST_(symbol1,symbol2) ->last_line, LAST_(symbol1,symbol2) ->last_column);\
fprintf(stderr, __VA_ARGS__); \
fprintf(stderr, "\n"); \
warning_found = true; \
}
lvalue_check_c::lvalue_check_c(symbol_c *ignore) {
error_count = 0;
current_display_error_level = 0;
current_il_operand = NULL;
search_varfb_instance_type = NULL;
search_var_instance_decl = NULL;
}
lvalue_check_c::~lvalue_check_c(void) {
}
int lvalue_check_c::get_error_count() {
return error_count;
}
#include <strings.h>
/* No writing to iterator variables (used in FOR loops) inside the loop itself */
void lvalue_check_c::check_assignment_to_controlvar(symbol_c *lvalue) {
for (unsigned int i = 0; i < control_variables.size(); i++) {
token_c *lvalue_name = get_var_name_c::get_name(lvalue);
if (compare_identifiers(lvalue_name, control_variables[i]) == 0) {
STAGE3_ERROR(0, lvalue, lvalue, "Assignment to FOR control variable is not allowed.");
break;
}
}
}
/* fb_instance.var := ... is not valid if var is output variable */
/* NOTE, if a fb_instance1.fb_instance2.fb_instance3.var is used, we must iteratively check that none of the
* FB records are declared as OUTPUT variables!!
* This is the reason why we have the while() loop in this function!
*
* Note, however, that the first record (fb_instance1 in the above example) may be an output variable!
*/
void lvalue_check_c::check_assignment_to_output(symbol_c *lvalue) {
decompose_var_instance_name_c decompose_lvalue(lvalue);
/* Get the first element/record of the potentially structured variable symbol */
/* Note that if symbol is pointing to an expression (or simply a literal value), it will return a NULL.
* Once we have implemented the check_assignment_to_expression() method, and abort calling the other checks (including this one)
* when an expression is found, we may replace this check with an assertion...
* if (NULL == struct_elem) ERROR;
*/
symbol_c *struct_elem = decompose_lvalue.get_next();
if (NULL == struct_elem) return;
symbol_c *type_decl = search_var_instance_decl->get_decl(struct_elem);
// symbol_c *type_id = spec_init_sperator_c::get_spec(type_decl); /* this is not required! search_base_type_c can handle spec_init symbols! */
symbol_c *basetype_id = search_base_type_c::get_basetype_id(/*type_id*/ type_decl);
/* If we can not determine the data type of the element, then the code must have a data type semantic error.
* This will have been caught by the data type semantic verifier, so we do not bother with this anymore!
*/
if (NULL == basetype_id) return;
/* Determine if the record/structure element is of a FB type. */
/* NOTE: If the structure element is not a FB type, then we can quit this check.
* Remember that the standard does not allow a STRUCT data type to have elements that are FB instances!
* Similarly, arrays of FB instances is also not allowed.
* So, as soon as we find one record/structure element that is not a FB, no other record/structure element
* will be of FB type, which means we can quit this check!
*/
function_block_type_symtable_t::iterator iter = function_block_type_symtable.find(basetype_id);
if (function_block_type_symtable.end() == iter) return;
function_block_declaration_c *fb_decl = iter->second;
while (NULL != (struct_elem = decompose_lvalue.get_next())) {
search_var_instance_decl_c fb_search_var_instance_decl(fb_decl);
if (search_var_instance_decl_c::output_vt == fb_search_var_instance_decl.get_vartype(struct_elem)) {
STAGE3_ERROR(0, struct_elem, struct_elem, "Assignment to FB output variable is not allowed.");
return; /* no need to carry on checking once the first error is found! */
}
/* prepare for any possible further record/structure elements */
type_decl = fb_search_var_instance_decl.get_decl(struct_elem);
basetype_id = search_base_type_c::get_basetype_id(type_decl);
if (NULL == basetype_id) return; /* same comment as above... */
iter = function_block_type_symtable.find(basetype_id);
if (function_block_type_symtable.end() == iter) return; /* same comment as above... */
fb_decl = iter->second;
}
}
/* No writing to CONSTANTs */
void lvalue_check_c::check_assignment_to_constant(symbol_c *lvalue) {
unsigned int option = search_var_instance_decl->get_option(lvalue);
if (option == search_var_instance_decl_c::constant_opt) {
STAGE3_ERROR(0, lvalue, lvalue, "Assignment to CONSTANT variables is not allowed.");
}
}
/* No assigning values to expressions. */
void lvalue_check_c::check_assignment_to_expression(symbol_c *lvalue) {
/* This may occur in function invocations, when passing values (possibly an expression) to one
* of the function's OUTPUT or IN_OUT parameters.
*/
if (
/*********************/
/* B 1.2 - Constants */
/*********************/
/*********************************/
/* B 1.2.XX - Reference Literals */
/*********************************/
(typeid( *lvalue ) == typeid( ref_value_null_literal_c )) || /* defined in IEC 61131-3 v3 - Basically the 'NULL' keyword! */
/******************************/
/* B 1.2.1 - Numeric Literals */
/******************************/
(typeid( *lvalue ) == typeid( real_c )) ||
(typeid( *lvalue ) == typeid( integer_c )) ||
(typeid( *lvalue ) == typeid( binary_integer_c )) ||
(typeid( *lvalue ) == typeid( octal_integer_c )) ||
(typeid( *lvalue ) == typeid( hex_integer_c )) ||
(typeid( *lvalue ) == typeid( neg_real_c )) ||
(typeid( *lvalue ) == typeid( neg_integer_c )) ||
(typeid( *lvalue ) == typeid( integer_literal_c )) ||
(typeid( *lvalue ) == typeid( real_literal_c )) ||
(typeid( *lvalue ) == typeid( bit_string_literal_c )) ||
(typeid( *lvalue ) == typeid( boolean_literal_c )) ||
(typeid( *lvalue ) == typeid( boolean_true_c )) || /* should not really be needed */
(typeid( *lvalue ) == typeid( boolean_false_c )) || /* should not really be needed */
/*******************************/
/* B.1.2.2 Character Strings */
/*******************************/
(typeid( *lvalue ) == typeid( double_byte_character_string_c )) ||
(typeid( *lvalue ) == typeid( single_byte_character_string_c )) ||
/***************************/
/* B 1.2.3 - Time Literals */
/***************************/
/************************/
/* B 1.2.3.1 - Duration */
/************************/
(typeid( *lvalue ) == typeid( duration_c )) ||
/************************************/
/* B 1.2.3.2 - Time of day and Date */
/************************************/
(typeid( *lvalue ) == typeid( time_of_day_c )) ||
(typeid( *lvalue ) == typeid( daytime_c )) || /* should not really be needed */
(typeid( *lvalue ) == typeid( date_c )) || /* should not really be needed */
(typeid( *lvalue ) == typeid( date_literal_c )) ||
(typeid( *lvalue ) == typeid( date_and_time_c )) ||
/***************************************/
/* B.3 - Language ST (Structured Text) */
/***************************************/
/***********************/
/* B 3.1 - Expressions */
/***********************/
(typeid( *lvalue ) == typeid( ref_expression_c )) || /* an extension to the IEC 61131-3 standard - based on the IEC 61131-3 v3 standard. Returns address of the variable! */
(typeid( *lvalue ) == typeid( or_expression_c )) ||
(typeid( *lvalue ) == typeid( xor_expression_c )) ||
(typeid( *lvalue ) == typeid( and_expression_c )) ||
(typeid( *lvalue ) == typeid( equ_expression_c )) ||
(typeid( *lvalue ) == typeid( notequ_expression_c )) ||
(typeid( *lvalue ) == typeid( lt_expression_c )) ||
(typeid( *lvalue ) == typeid( gt_expression_c )) ||
(typeid( *lvalue ) == typeid( le_expression_c )) ||
(typeid( *lvalue ) == typeid( ge_expression_c )) ||
(typeid( *lvalue ) == typeid( add_expression_c )) ||
(typeid( *lvalue ) == typeid( sub_expression_c )) ||
(typeid( *lvalue ) == typeid( mul_expression_c )) ||
(typeid( *lvalue ) == typeid( div_expression_c )) ||
(typeid( *lvalue ) == typeid( mod_expression_c )) ||
(typeid( *lvalue ) == typeid( power_expression_c )) ||
(typeid( *lvalue ) == typeid( neg_expression_c )) ||
(typeid( *lvalue ) == typeid( not_expression_c )) ||
(typeid( *lvalue ) == typeid( function_invocation_c )))
STAGE3_ERROR(0, lvalue, lvalue, "Assignment to an expression or a literal value is not allowed.");
}
/* No assigning values to IL lists. */
void lvalue_check_c::check_assignment_to_il_list(symbol_c *lvalue) {
/* This may occur in formal invocations in IL, where an embedded IL list may be used instead of a symbolic_variable
* when passing an IN_OUT parameter! Note that it will never occur to OUT parameters, as the syntax does not allow it,
* although this does not affect out algorithm here!
*/
if (
/****************************************/
/* B.2 - Language IL (Instruction List) */
/****************************************/
/***********************************/
/* B 2.1 Instructions and Operands */
/***********************************/
(typeid( *lvalue ) == typeid( simple_instr_list_c)))
STAGE3_ERROR(0, lvalue, lvalue, "Assigning an IL list to an IN_OUT parameter is not allowed.");
}
void lvalue_check_c::verify_is_lvalue(symbol_c *lvalue) {
if (NULL == lvalue) return; // missing operand in source code being compiled. Error will be caught and reported by datatype checking!
int init_error_count = error_count; /* stop the checks once an error has been found... */
if (error_count == init_error_count) check_assignment_to_expression(lvalue);
if (error_count == init_error_count) check_assignment_to_il_list (lvalue);
if (error_count == init_error_count) check_assignment_to_controlvar(lvalue);
if (error_count == init_error_count) check_assignment_to_output (lvalue);
if (error_count == init_error_count) check_assignment_to_constant (lvalue);
}
/* check whether all values passed to OUT or IN_OUT parameters are legal lvalues. */
/*
* All parameters being passed to the called function MUST be in the parameter list to which f_call points to!
* This means that, for non formal function calls in IL, de current (default value) must be artificially added to the
* beginning of the parameter list BEFORE calling handle_function_call().
*/
#include <string.h> /* required for strcmp() */
void lvalue_check_c::check_nonformal_call(symbol_c *f_call, symbol_c *f_decl) {
/* if data type semantic verification was unable to determine which function is being called,
* then it does not make sense to go ahead and check for lvalues to unknown parameters.
* We simply bug out!
*/
if (NULL == f_decl) return;
symbol_c *call_param_value;
identifier_c *param_name;
function_param_iterator_c fp_iterator(f_decl);
function_call_param_iterator_c fcp_iterator(f_call);
/* Iterating through the non-formal parameters of the function call */
while((call_param_value = fcp_iterator.next_nf()) != NULL) {
/* Iterate to the next parameter of the function being called.
* Get the name of that parameter, and ignore if EN or ENO.
*/
do {
param_name = fp_iterator.next();
/* If there is no other parameter declared, then we are passing too many parameters... */
/* This error should have been caught in data type verification, so we simply abandon our check! */
if(param_name == NULL) return;
} while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0));
/* Determine the direction (IN, OUT, IN_OUT) of the parameter... */
function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
/* We only process the parameter value if the paramater itself is valid... */
if (param_name != NULL) {
/* If the parameter is either OUT or IN_OUT, we check if 'call_param_value' is a valid lvalue */
if ((function_param_iterator_c::direction_out == param_direction) || (function_param_iterator_c::direction_inout == param_direction))
verify_is_lvalue(call_param_value);
/* parameter values to IN parameters may be expressions with function invocations that must also be checked! */
/* parameter values to OUT or IN_OUT parameters may contain arrays, whose subscripts contain expressions that must be checked! */
call_param_value->accept(*this);
}
}
}
/* check whether all values passed to OUT or IN_OUT parameters are legal lvalues. */
void lvalue_check_c::check_formal_call(symbol_c *f_call, symbol_c *f_decl) {
/* if data type semantic verification was unable to determine which function is being called,
* then it does not make sense to go ahead and check for lvalues to unknown parameters.
* We simply bug out!
*/
if (NULL == f_decl) return;
symbol_c *call_param_name;
function_param_iterator_c fp_iterator(f_decl);
function_call_param_iterator_c fcp_iterator(f_call);
/* Iterating through the formal parameters of the function call */
while((call_param_name = fcp_iterator.next_f()) != NULL) {
/* Obtaining the value being passed in the function call */
symbol_c *call_param_value = fcp_iterator.get_current_value();
if (NULL == call_param_value) ERROR;
/* Find the corresponding parameter in function declaration, and it's direction (IN, OUT, IN_OUT) */
identifier_c *param_name = fp_iterator.search(call_param_name);
function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
/* We only process the parameter value if the paramater itself is valid... */
if (param_name != NULL) {
/* If the parameter is either OUT or IN_OUT, we check if 'call_param_value' is a valid lvalue */
if ((function_param_iterator_c::direction_out == param_direction) || (function_param_iterator_c::direction_inout == param_direction))
verify_is_lvalue(call_param_value);
/* parameter values to IN parameters may be expressions with function invocations that must also be checked! */
/* parameter values to OUT or IN_OUT parameters may contain arrays, whose subscripts contain expressions that must be checked! */
call_param_value->accept(*this);
}
}
}
/**************************************/
/* B 1.5 - Program organisation units */
/**************************************/
/***********************/
/* B 1.5.1 - Functions */
/***********************/
void *lvalue_check_c::visit(function_declaration_c *symbol) {
search_varfb_instance_type = new search_varfb_instance_type_c(symbol);
search_var_instance_decl = new search_var_instance_decl_c(symbol);
symbol->function_body->accept(*this);
delete search_varfb_instance_type;
delete search_var_instance_decl;
search_varfb_instance_type = NULL;
search_var_instance_decl = NULL;
return NULL;
}
/*****************************/
/* B 1.5.2 - Function blocks */
/*****************************/
void *lvalue_check_c::visit(function_block_declaration_c *symbol) {
search_varfb_instance_type = new search_varfb_instance_type_c(symbol);
search_var_instance_decl = new search_var_instance_decl_c(symbol);
symbol->fblock_body->accept(*this);
delete search_varfb_instance_type;
delete search_var_instance_decl;
search_varfb_instance_type = NULL;
search_var_instance_decl = NULL;
return NULL;
}
/**********************/
/* B 1.5.3 - Programs */
/**********************/
void *lvalue_check_c::visit(program_declaration_c *symbol) {
search_varfb_instance_type = new search_varfb_instance_type_c(symbol);
search_var_instance_decl = new search_var_instance_decl_c(symbol);
symbol->function_block_body->accept(*this);
delete search_varfb_instance_type;
delete search_var_instance_decl;
search_varfb_instance_type = NULL;
search_var_instance_decl = NULL;
return NULL;
}
/****************************************/
/* B.2 - Language IL (Instruction List) */
/****************************************/
/***********************************/
/* B 2.1 Instructions and Operands */
/***********************************/
void *lvalue_check_c::visit(il_instruction_c *symbol) {
/* il_instruction will be NULL when parsing a label with no instruction
* e.g.: label1: <---- il_instruction = NULL!
* LD 33
* ...
*/
if (NULL != symbol->il_instruction)
symbol->il_instruction->accept(*this);
return NULL;
}
void *lvalue_check_c::visit(il_simple_operation_c *symbol) {
current_il_operand = symbol->il_operand;
symbol->il_simple_operator->accept(*this);
current_il_operand = NULL;
return NULL;
}
/* | function_name [il_operand_list] */
/* NOTE: The parameters 'called_function_declaration' and 'extensible_param_count' are used to pass data between the stage 3 and stage 4. */
// SYM_REF2(il_function_call_c, function_name, il_operand_list, symbol_c *called_function_declaration; int extensible_param_count;)
void *lvalue_check_c::visit(il_function_call_c *symbol) {
/* The first parameter of a non formal function call in IL will be the 'current value' (i.e. the prev_il_instruction)
* In order to be able to handle this without coding special cases, we will simply prepend that symbol
* to the il_operand_list, and remove it after calling handle_function_call().
*
* 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 at the end of this method.
*/
/* TODO: Copying the location data will result in confusing error message.
* We need to make this better, by inserting code to handle this special situation explicitly!
*/
/* NOTE: When calling a function, using the 'current value' as the first parameter of the function invocation
* implies that we can only call functions whose first parameter is IN. It would not do to pass
* the 'current value' to an OUT or IN_OUT parameter.
* In order to make sure that this will be caught by the check_nonformal_call() function,
* we add a symbol that cannot be an lvalue; in this case, a real_c (REAL literal).
*/
real_c param_value(NULL);
*((symbol_c *)(¶m_value)) = *((symbol_c *)symbol); /* copy the symbol location (file, line, offset) data */
if (NULL == symbol->il_operand_list) symbol->il_operand_list = new il_operand_list_c;
if (NULL == symbol->il_operand_list) ERROR;
((list_c *)symbol->il_operand_list)->insert_element(¶m_value, 0);
check_nonformal_call(symbol, symbol->called_function_declaration);
/* 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! */
delete symbol->il_operand_list;
symbol->il_operand_list = NULL;
}
return NULL;
}
/* il_call_operator prev_declared_fb_name
* | il_call_operator prev_declared_fb_name '(' ')'
* | il_call_operator prev_declared_fb_name '(' eol_list ')'
* | 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 */
// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list, symbol_c *called_fb_declaration)
void *lvalue_check_c::visit(il_fb_call_c *symbol) {
if (NULL != symbol->il_operand_list) check_nonformal_call(symbol, symbol->called_fb_declaration);
if (NULL != symbol-> il_param_list) check_formal_call(symbol, symbol->called_fb_declaration);
return NULL;
}
/* | function_name '(' eol_list [il_param_list] ')' */
/* NOTE: The parameter 'called_function_declaration' is used to pass data between the stage 3 and stage 4. */
// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list, symbol_c *called_function_declaration; int extensible_param_count;)
void *lvalue_check_c::visit(il_formal_funct_call_c *symbol) {
check_formal_call(symbol, symbol->called_function_declaration);
return NULL;
}
/*******************/
/* B 2.2 Operators */
/*******************/
void *lvalue_check_c::visit(ST_operator_c *symbol) {
verify_is_lvalue(current_il_operand);
return NULL;
}
void *lvalue_check_c::visit(STN_operator_c *symbol) {
verify_is_lvalue(current_il_operand);
return NULL;
}
void *lvalue_check_c::visit(S_operator_c *symbol) {
verify_is_lvalue(current_il_operand);
return NULL;
}
void *lvalue_check_c::visit(R_operator_c *symbol) {
verify_is_lvalue(current_il_operand);
return NULL;
}
/***************************************/
/* B.3 - Language ST (Structured Text) */
/***************************************/
/***********************/
/* B 3.1 - Expressions */
/***********************/
// SYM_REF3(function_invocation_c, function_name, formal_param_list, nonformal_param_list, symbol_c *called_function_declaration; int extensible_param_count; std::vector <symbol_c *> candidate_functions;)
void *lvalue_check_c::visit(function_invocation_c *symbol) {
if (NULL != symbol->formal_param_list ) check_formal_call (symbol, symbol->called_function_declaration);
if (NULL != symbol->nonformal_param_list) check_nonformal_call(symbol, symbol->called_function_declaration);
return NULL;
}
/*********************************/
/* B 3.2.1 Assignment Statements */
/*********************************/
void *lvalue_check_c::visit(assignment_statement_c *symbol) {
verify_is_lvalue(symbol->l_exp);
/* We call visit r_exp to check function_call */
symbol->r_exp->accept(*this);
return NULL;
}
/*****************************************/
/* B 3.2.2 Subprogram Control Statements */
/*****************************************/
void *lvalue_check_c::visit(fb_invocation_c *symbol) {
if (NULL != symbol->formal_param_list ) check_formal_call (symbol, symbol->called_fb_declaration);
if (NULL != symbol->nonformal_param_list) check_nonformal_call(symbol, symbol->called_fb_declaration);
return NULL;
}
/********************************/
/* B 3.2.4 Iteration Statements */
/********************************/
void *lvalue_check_c::visit(for_statement_c *symbol) {
verify_is_lvalue(symbol->control_variable);
control_variables.push_back(get_var_name_c::get_name(symbol->control_variable));
symbol->statement_list->accept(*this);
control_variables.pop_back();
return NULL;
}