conti@508: /* conti@508: * matiec - a compiler for the programming languages defined in IEC 61131-3 conti@508: * conti@508: * Copyright (C) 2009-2012 Mario de Sousa (msousa@fe.up.pt) conti@508: * Copyright (C) 2012 Manuele Conti (conti.ma@alice.it) conti@508: * conti@508: * conti@508: * This program is free software: you can redistribute it and/or modify conti@508: * it under the terms of the GNU General Public License as published by conti@508: * the Free Software Foundation, either version 3 of the License, or conti@508: * (at your option) any later version. conti@508: * conti@508: * This program is distributed in the hope that it will be useful, conti@508: * but WITHOUT ANY WARRANTY; without even the implied warranty of conti@508: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the conti@508: * GNU General Public License for more details. conti@508: * conti@508: * You should have received a copy of the GNU General Public License conti@508: * along with this program. If not, see . conti@508: * conti@508: * conti@508: * This code is made available on the understanding that it will not be conti@508: * used in safety-critical situations without a full and competent review. conti@508: */ conti@508: conti@508: /* conti@508: * An IEC 61131-3 compiler. conti@508: * conti@508: * Based on the conti@508: * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10) conti@508: * conti@508: */ conti@508: conti@508: conti@508: #include "lvalue_check.hh" conti@508: conti@508: #define FIRST_(symbol1, symbol2) (((symbol1)->first_order < (symbol2)->first_order) ? (symbol1) : (symbol2)) conti@508: #define LAST_(symbol1, symbol2) (((symbol1)->last_order > (symbol2)->last_order) ? (symbol1) : (symbol2)) conti@508: conti@508: #define STAGE3_ERROR(error_level, symbol1, symbol2, ...) { \ conti@508: if (current_display_error_level >= error_level) { \ conti@508: fprintf(stderr, "%s:%d-%d..%d-%d: error: ", \ conti@508: FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\ conti@508: LAST_(symbol1,symbol2) ->last_line, LAST_(symbol1,symbol2) ->last_column);\ conti@508: fprintf(stderr, __VA_ARGS__); \ conti@508: fprintf(stderr, "\n"); \ msousa@510: error_count++; \ conti@508: } \ conti@508: } conti@508: conti@508: conti@508: #define STAGE3_WARNING(symbol1, symbol2, ...) { \ conti@508: fprintf(stderr, "%s:%d-%d..%d-%d: warning: ", \ conti@508: FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\ conti@508: LAST_(symbol1,symbol2) ->last_line, LAST_(symbol1,symbol2) ->last_column);\ conti@508: fprintf(stderr, __VA_ARGS__); \ conti@508: fprintf(stderr, "\n"); \ conti@508: warning_found = true; \ conti@508: } conti@508: conti@508: conti@508: lvalue_check_c::lvalue_check_c(symbol_c *ignore) { msousa@510: error_count = 0; conti@508: } conti@508: conti@508: lvalue_check_c::~lvalue_check_c(void) { conti@508: } conti@508: msousa@510: int lvalue_check_c::get_error_count() { msousa@510: return error_count; conti@508: } conti@508: msousa@509: msousa@509: #include conti@508: /* No writing to iterator variables (used in FOR loops) inside the loop itself */ msousa@509: void lvalue_check_c::check_assignment_to_controlvar(symbol_c *lvalue) { conti@508: for (unsigned int i = 0; i < control_variables.size(); i++) { msousa@512: token_c *lvalue_name = get_var_name_c::get_name(lvalue); msousa@512: if (compare_identifiers(lvalue_name, control_variables[i]) == 0) { msousa@512: STAGE3_ERROR(0, lvalue, lvalue, "Assignment to FOR control variable is not allowed."); conti@508: break; conti@508: } conti@508: } conti@508: } conti@508: msousa@509: msousa@510: /* fb_instance.var := ... is not valid if var is output variable */ msousa@510: /* NOTE, if a fb_instance1.fb_instance2.fb_instance3.var is used, we must iteratively check that none of the msousa@510: * FB records are declared as OUTPUT variables!! msousa@510: * This is the reason why we have the while() loop in this function! msousa@510: */ msousa@510: void lvalue_check_c::check_assignment_to_output(symbol_c *lvalue) { msousa@510: decompose_var_instance_name_c decompose_lvalue(lvalue); msousa@510: search_base_type_c search_base_type; msousa@510: msousa@510: symbol_c *struct_elem = decompose_lvalue.next_part(); msousa@510: symbol_c *type_decl = search_var_instance_decl->get_decl(struct_elem); msousa@510: // 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! */ msousa@510: symbol_c *basetype_id = search_base_type.get_basetype_id(/*type_id*/ type_decl); msousa@510: /* If we can not determine the data type of the element, then the code must have a data type semantic error. msousa@510: * This will have been caught by the data type semantic verifier, so we do not bother with this anymore! msousa@510: */ msousa@510: if (NULL == basetype_id) return; msousa@510: msousa@510: /* Determine if the record/structure element is of a FB type. */ msousa@510: /* NOTE: If the structure element is not a FB type, then we can quit this check. msousa@510: * Remember that the standard does not allow a STRUCT data type to have elements that are FB instances! msousa@510: * Similarly, arrays of FB instances is also not allowed. msousa@510: * So, as soon as we find one record/structure element that is not a FB, no other record/structure element msousa@510: * will be of FB type, which means we can quit this check! msousa@510: */ msousa@510: function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(basetype_id); msousa@510: if (function_block_type_symtable.end_value() == fb_decl) return; msousa@510: msousa@510: while (NULL != (struct_elem = decompose_lvalue.next_part())) { msousa@510: search_var_instance_decl_c fb_search_var_instance_decl(fb_decl); msousa@510: if (search_var_instance_decl_c::output_vt == fb_search_var_instance_decl.get_vartype(struct_elem)) { msousa@510: STAGE3_ERROR(0, struct_elem, struct_elem, "Assignment to FB output variable is not allowed."); msousa@510: return; /* no need to carry on checking once the first error is found! */ conti@508: } msousa@510: msousa@510: /* prepare for any possible further record/structure elements */ msousa@510: type_decl = fb_search_var_instance_decl.get_decl(struct_elem); msousa@510: basetype_id = search_base_type.get_basetype_id(type_decl); msousa@510: if (NULL == basetype_id) return; /* same comment as above... */ msousa@510: fb_decl = function_block_type_symtable.find_value(basetype_id); msousa@510: if (function_block_type_symtable.end_value() == fb_decl) return; /* same comment as above... */ conti@508: } conti@508: } conti@508: msousa@509: conti@508: /* No writing to CONSTANTs */ msousa@509: void lvalue_check_c::check_assignment_to_constant(symbol_c *lvalue) { msousa@509: unsigned int option = search_var_instance_decl->get_option(lvalue); conti@508: if (option == search_var_instance_decl_c::constant_opt) { msousa@509: STAGE3_ERROR(0, lvalue, lvalue, "Assignment to CONSTANT variables is not be allowed."); msousa@509: } msousa@509: } msousa@509: msousa@509: msousa@509: /* No assigning values to expressions. */ msousa@509: void lvalue_check_c::check_assignment_to_expression(symbol_c *lvalue) { msousa@509: /* TODO: check whether the lvalue is an expresion! */ msousa@509: /* This may occur in function invocations, when passing values (possibly an expression) to one msousa@510: * of the function's OUTPUT or IN_OUT parameters. conti@508: */ msousa@509: } msousa@509: msousa@509: msousa@509: msousa@509: void lvalue_check_c::verify_is_lvalue(symbol_c *lvalue) { msousa@510: check_assignment_to_expression(lvalue); msousa@509: check_assignment_to_controlvar(lvalue); msousa@509: check_assignment_to_output(lvalue); msousa@509: check_assignment_to_constant(lvalue); msousa@509: } msousa@509: msousa@509: msousa@509: msousa@509: msousa@509: /* check whether all values passed to OUT or IN_OUT parameters are legal lvalues. */ msousa@513: /* msousa@513: * All parameters being passed to the called function MUST be in the parameter list to which f_call points to! msousa@513: * This means that, for non formal function calls in IL, de current (default value) must be artificially added to the msousa@513: * beginning of the parameter list BEFORE calling handle_function_call(). msousa@513: */ msousa@513: #include /* required for strcmp() */ msousa@509: void lvalue_check_c::check_nonformal_call(symbol_c *f_call, symbol_c *f_decl) { msousa@513: symbol_c *call_param_value; msousa@513: identifier_c *param_name; msousa@513: function_param_iterator_c fp_iterator(f_decl); msousa@513: function_call_param_iterator_c fcp_iterator(f_call); msousa@513: msousa@513: /* Iterating through the non-formal parameters of the function call */ msousa@513: while((call_param_value = fcp_iterator.next_nf()) != NULL) { msousa@513: /* Iterate to the next parameter of the function being called. msousa@513: * Get the name of that parameter, and ignore if EN or ENO. msousa@513: */ msousa@513: do { msousa@513: param_name = fp_iterator.next(); msousa@513: /* If there is no other parameter declared, then we are passing too many parameters... */ msousa@513: /* This error should have been caught in data type verification, so we simply abandon our check! */ msousa@513: if(param_name == NULL) return; msousa@513: } while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0)); msousa@513: msousa@513: /* Find the corresponding parameter in function declaration, and it's direction (IN, OUT, IN_OUT) */ msousa@513: function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); msousa@513: msousa@513: /* We only check if 'call_param_value' is a valid lvalue if the value is being passed msousa@513: * to a valid paramater of the function being called, and that parameter is either OUT or IN_OUT. msousa@513: */ msousa@513: if ((param_name != NULL) && ((function_param_iterator_c::direction_out == param_direction) || (function_param_iterator_c::direction_inout == param_direction))) { msousa@513: verify_is_lvalue(call_param_value); msousa@513: } msousa@513: } msousa@513: } msousa@513: msousa@513: msousa@513: msousa@513: msousa@509: msousa@509: msousa@509: /* check whether all values passed to OUT or IN_OUT parameters are legal lvalues. */ msousa@509: void lvalue_check_c::check_formal_call(symbol_c *f_call, symbol_c *f_decl) { msousa@509: /* if data type semantic verification was unable to determine which function is being called, msousa@509: * then it does not make sense to go ahead and check for lvalues to unknown parameters. msousa@509: * We simply bug out! msousa@509: */ msousa@509: if (NULL == f_decl) return; msousa@509: msousa@509: symbol_c *call_param_name; msousa@509: function_param_iterator_c fp_iterator(f_decl); conti@508: function_call_param_iterator_c fcp_iterator(f_call); msousa@509: msousa@509: /* Iterating through the formal parameters of the function call */ msousa@509: while((call_param_name = fcp_iterator.next_f()) != NULL) { msousa@509: msousa@509: /* Obtaining the value being passed in the function call */ msousa@509: symbol_c *call_param_value = fcp_iterator.get_current_value(); msousa@509: if (NULL == call_param_value) ERROR; msousa@509: msousa@509: /* Find the corresponding parameter in function declaration, and it's direction (IN, OUT, IN_OUT) */ msousa@509: identifier_c *param_name = fp_iterator.search(call_param_name); msousa@509: function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); msousa@509: msousa@509: /* We only check if 'call_param_value' is a valid lvalue if the value is being passed msousa@509: * to a valid paramater of the function being called, and that parameter is either OUT or IN_OUT. msousa@509: */ msousa@510: if ((param_name != NULL) && ((function_param_iterator_c::direction_out == param_direction) || (function_param_iterator_c::direction_inout == param_direction))) { msousa@509: verify_is_lvalue(call_param_value); conti@508: } msousa@509: } msousa@509: } msousa@509: msousa@509: msousa@509: msousa@509: conti@508: conti@508: conti@508: conti@508: /**************************************/ conti@508: /* B 1.5 - Program organisation units */ conti@508: /**************************************/ conti@508: /***********************/ conti@508: /* B 1.5.1 - Functions */ conti@508: /***********************/ conti@508: void *lvalue_check_c::visit(function_declaration_c *symbol) { conti@508: search_varfb_instance_type = new search_varfb_instance_type_c(symbol); conti@508: search_var_instance_decl = new search_var_instance_decl_c(symbol); conti@508: symbol->function_body->accept(*this); conti@508: delete search_varfb_instance_type; conti@508: delete search_var_instance_decl; conti@508: search_varfb_instance_type = NULL; conti@508: search_var_instance_decl = NULL; conti@508: return NULL; conti@508: } conti@508: conti@508: /*****************************/ conti@508: /* B 1.5.2 - Function blocks */ conti@508: /*****************************/ conti@508: void *lvalue_check_c::visit(function_block_declaration_c *symbol) { conti@508: search_varfb_instance_type = new search_varfb_instance_type_c(symbol); conti@508: search_var_instance_decl = new search_var_instance_decl_c(symbol); conti@508: symbol->fblock_body->accept(*this); conti@508: delete search_varfb_instance_type; conti@508: delete search_var_instance_decl; conti@508: search_varfb_instance_type = NULL; conti@508: search_var_instance_decl = NULL; conti@508: return NULL; conti@508: } conti@508: conti@508: /**********************/ conti@508: /* B 1.5.3 - Programs */ conti@508: /**********************/ conti@508: void *lvalue_check_c::visit(program_declaration_c *symbol) { conti@508: search_varfb_instance_type = new search_varfb_instance_type_c(symbol); conti@508: search_var_instance_decl = new search_var_instance_decl_c(symbol); conti@508: symbol->function_block_body->accept(*this); conti@508: delete search_varfb_instance_type; conti@508: delete search_var_instance_decl; conti@508: search_varfb_instance_type = NULL; conti@508: search_var_instance_decl = NULL; conti@508: return NULL; conti@508: } conti@508: conti@508: /***************************************/ conti@508: /* B.3 - Language ST (Structured Text) */ conti@508: /***************************************/ conti@508: /***********************/ conti@508: /* B 3.1 - Expressions */ conti@508: /***********************/ msousa@509: // SYM_REF3(function_invocation_c, function_name, formal_param_list, nonformal_param_list, symbol_c *called_function_declaration; int extensible_param_count; std::vector candidate_functions;) conti@508: void *lvalue_check_c::visit(function_invocation_c *symbol) { msousa@510: if (NULL != symbol->formal_param_list ) check_formal_call (symbol, symbol->called_function_declaration); msousa@510: if (NULL != symbol->nonformal_param_list) check_nonformal_call(symbol, symbol->called_function_declaration); conti@508: return NULL; conti@508: } conti@508: conti@508: /*********************************/ conti@508: /* B 3.2.1 Assignment Statements */ conti@508: /*********************************/ conti@508: void *lvalue_check_c::visit(assignment_statement_c *symbol) { msousa@509: verify_is_lvalue(symbol->l_exp); conti@508: /* We call visit r_exp to check function_call */ conti@508: symbol->r_exp->accept(*this); conti@508: return NULL; conti@508: } conti@508: conti@508: /********************************/ conti@508: /* B 3.2.4 Iteration Statements */ conti@508: /********************************/ conti@508: void *lvalue_check_c::visit(for_statement_c *symbol) { msousa@512: control_variables.push_back(get_var_name_c::get_name(symbol->control_variable)); conti@508: symbol->statement_list->accept(*this); conti@508: control_variables.pop_back(); conti@508: return NULL; conti@508: } conti@508: conti@508: conti@508: conti@508: conti@508: conti@508: conti@508: