1 /*

     2  *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3  *

     4  *  Copyright (C) 2009-2012  Mario de Sousa (msousa@fe.up.pt)

     5  *  Copyright (C) 2012       Manuele Conti (manuele.conti@sirius-es.it)

     6  *  Copyright (C) 2012       Matteo Facchinetti (matteo.facchinetti@sirius-es.it)

     7  *

     8  *

     9  *  This program is free software: you can redistribute it and/or modify

    10  *  it under the terms of the GNU General Public License as published by

    11  *  the Free Software Foundation, either version 3 of the License, or

    12  *  (at your option) any later version.

    13  *

    14  *  This program is distributed in the hope that it will be useful,

    15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17  *  GNU General Public License for more details.

    18  *

    19  *  You should have received a copy of the GNU General Public License

    20  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    21  *

    22  *

    23  * This code is made available on the understanding that it will not be

    24  * used in safety-critical situations without a full and competent review.

    25  */

    26 

    27 /*

    28  * An IEC 61131-3 compiler.

    29  *

    30  * Based on the

    31  * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    32  *

    33  */

    34 

    35 /* NOTE: The algorithm implemented here assumes that flow control analysis has already been completed!

    36  *       BEFORE running this visitor, be sure to CALL the flow_control_analysis_c visitor!

    37  */

    38 

    39 

    40 /*

    41  *  Fill the candidate datatype list for all symbols that may legally 'have' a data type (e.g. variables, literals, function calls, expressions, etc.)

    42  * 

    43  *  The candidate datatype list will be filled with a list of all the data types that expression may legally take.

    44  *  For example, the very simple literal '0' (as in foo := 0), may represent a:

    45  *    BOOL, BYTE, WORD, DWORD, LWORD, USINT, SINT, UINT, INT, UDINT, DINT, ULINT, LINT (as well as the SAFE versions of these data tyes too!)

    46  */

    47 

    48 

    49 #include "../absyntax_utils/absyntax_utils.hh"

    50 #include "datatype_functions.hh"

    51 

    52 class fill_candidate_datatypes_c: public iterator_visitor_c {

    53 

    54   private:

    55     search_varfb_instance_type_c *search_varfb_instance_type;

    56     search_base_type_c search_base_type;

    57     /* When calling a function block, we must first find it's type,

    58      * by searching through the declarations of the variables currently

    59      * in scope.

    60      * This class does just that...

    61      * A new object instance is instantiated whenever we start checking semantics

    62      * for a function block type declaration, or a program declaration.

    63      * This object instance will then later be called while the

    64      * function block's or the program's body is being handled.

    65      *

    66      * Note that functions cannot contain calls to function blocks,

    67      * so we do not create an object instance when handling

    68      * a function declaration.

    69      */

    70     //     search_var_instance_decl_c *search_var_instance_decl;

    71 

    72     /* This variable was created to pass information from

    73      * fill_candidate_datatypes_c::visit(case_statement_c *symbol) function to

    74      * fill_candidate_datatypes_c::visit(case_list_c *symbol) function.

    75      */

    76 //     symbol_c *case_expression_type;

    77 

    78     /* In IL code, once we find a type mismatch error, it is best to

    79      * ignore any further errors until the end of the logical operation,

    80      * i.e. until the next LD.

    81      * However, we cannot clear the il_error flag on all LD operations,

    82      * as these may also be used within parenthesis. LD operations

    83      * within parenthesis may not clear the error flag.

    84      * We therefore need a counter to know how deep inside a parenthesis

    85      * structure we are.

    86      */

    87 //     int  il_parenthesis_level;

    88 //     bool error_found;

    89 

    90     /* Pointer to the previous IL instruction, which contains the current data type (actually, the list of candidate data types) of the data stored in the IL stack, i.e. the default variable, a.k.a. accumulator */

    91     symbol_c *prev_il_instruction;

    92     /* the current IL operand being analyzed */

    93     symbol_c *il_operand;

    94     symbol_c *widening_conversion(symbol_c *left_type, symbol_c *right_type, const struct widen_entry widen_table[]);

    95 

    96     /* Match a function declaration with a function call through their parameters.*/

    97     /* returns true if compatible function/FB invocation, otherwise returns false */

    98     bool  match_nonformal_call(symbol_c *f_call, symbol_c *f_decl);

    99     bool  match_formal_call   (symbol_c *f_call, symbol_c *f_decl, symbol_c **first_param_datatype = NULL);

   100     void  handle_function_call(symbol_c *fcall, generic_function_call_t fcall_data);

   101     void *handle_implicit_il_fb_call(symbol_c *il_instruction, const char *param_name, symbol_c *&called_fb_declaration);

   102     void *handle_binary_expression(const struct widen_entry widen_table[], symbol_c *symbol, symbol_c *l_expr, symbol_c *r_expr);

   103     void *handle_binary_operator  (const struct widen_entry widen_table[], symbol_c *symbol, symbol_c *l_expr, symbol_c *r_expr);

   104     void *handle_conditional_il_flow_control_operator(symbol_c *symbol);

   105     

   106     /* a helper function... */

   107     symbol_c *base_type(symbol_c *symbol);    

   108     

   109     /* add a data type to a candidate data type list, while guaranteeing no duplicate entries! */

   110     /* Returns true if it really did add the datatype to the list, or false if it was already present in the list! */

   111     bool add_datatype_to_candidate_list  (symbol_c *symbol, symbol_c *datatype);

   112     bool add_2datatypes_to_candidate_list(symbol_c *symbol, symbol_c *datatype1, symbol_c *datatype2);

   113     void remove_incompatible_datatypes(symbol_c *symbol);

   114     

   115     

   116   public:

   117     fill_candidate_datatypes_c(symbol_c *ignore);

   118     virtual ~fill_candidate_datatypes_c(void);

   119 

   120 

   121     /*********************/

   122     /* B 1.2 - Constants */

   123     /*********************/

   124     /******************************/

   125     /* B 1.2.1 - Numeric Literals */

   126     /******************************/

   127     void *handle_any_integer(symbol_c *symbol);

   128     void *handle_any_real   (symbol_c *symbol);

   129     void *handle_any_literal(symbol_c *symbol, symbol_c *symbol_value, symbol_c *symbol_type);

   130     

   131     void *visit(real_c *symbol);

   132     void *visit(integer_c *symbol);

   133     void *visit(neg_real_c *symbol);

   134     void *visit(neg_integer_c *symbol);

   135     void *visit(binary_integer_c *symbol);

   136     void *visit(octal_integer_c *symbol);

   137     void *visit(hex_integer_c *symbol);

   138     void *visit(integer_literal_c *symbol);

   139     void *visit(real_literal_c *symbol);

   140     void *visit(bit_string_literal_c *symbol);

   141     void *visit(boolean_literal_c *symbol);

   142     void *visit(boolean_true_c *symbol);

   143     void *visit(boolean_false_c *symbol);

   144 

   145     /*******************************/

   146     /* B.1.2.2   Character Strings */

   147     /*******************************/

   148     void *visit(double_byte_character_string_c *symbol);

   149     void *visit(single_byte_character_string_c *symbol);

   150 

   151     /***************************/

   152     /* B 1.2.3 - Time Literals */

   153     /***************************/

   154     /************************/

   155     /* B 1.2.3.1 - Duration */

   156     /************************/

   157     void *visit(duration_c *symbol);

   158 

   159     /************************************/

   160     /* B 1.2.3.2 - Time of day and Date */

   161     /************************************/

   162     void *visit(time_of_day_c *symbol);

   163     void *visit(date_c *symbol);

   164     void *visit(date_and_time_c *symbol);

   165 

   166 

   167     /**********************/

   168     /* B 1.3 - Data types */

   169     /**********************/

   170     /********************************/

   171     /* B 1.3.3 - Derived data types */

   172     /********************************/

   173     void *visit(simple_spec_init_c *symbol);

   174     void *visit(subrange_c *symbol);

   175 //  void *visit(data_type_declaration_c *symbol);

   176     void *visit(enumerated_value_c *symbol);

   177 

   178     /*********************/

   179     /* B 1.4 - Variables */

   180     /*********************/

   181     void *visit(symbolic_variable_c *symbol);

   182 

   183     /********************************************/

   184     /* B 1.4.1 - Directly Represented Variables */

   185     /********************************************/

   186     void *visit(direct_variable_c *symbol);

   187 

   188     /*************************************/

   189     /* B 1.4.2 - Multi-element variables */

   190     /*************************************/

   191     void *visit(array_variable_c *symbol);

   192     void *visit(structured_variable_c *symbol);

   193 

   194     /******************************************/

   195     /* B 1.4.3 - Declaration & Initialisation */

   196     /******************************************/

   197     void *visit(var1_list_c *symbol);

   198     void *visit(location_c *symbol);

   199     void *visit(located_var_decl_c *symbol);

   200 

   201 

   202     /**************************************/

   203     /* B 1.5 - Program organization units */

   204     /**************************************/

   205     /***********************/

   206     /* B 1.5.1 - Functions */

   207     /***********************/

   208     void *visit(function_declaration_c *symbol);

   209 

   210     /*****************************/

   211     /* B 1.5.2 - Function blocks */

   212     /*****************************/

   213     void *visit(function_block_declaration_c *symbol);

   214 

   215     /**********************/

   216     /* B 1.5.3 - Programs */

   217     /**********************/

   218     void *visit(program_declaration_c *symbol);

   219 

   220     /********************************/

   221     /* B 1.7 Configuration elements */

   222     /********************************/

   223     void *visit(configuration_declaration_c *symbol);

   224 

   225     /****************************************/

   226     /* B.2 - Language IL (Instruction List) */

   227     /****************************************/

   228     /***********************************/

   229     /* B 2.1 Instructions and Operands */

   230     /***********************************/

   231     void *visit(instruction_list_c *symbol);

   232     void *visit(il_instruction_c *symbol);

   233     void *visit(il_simple_operation_c *symbol);

   234     void *visit(il_function_call_c *symbol);

   235     void *visit(il_expression_c *symbol);

   236     void *visit(il_jump_operation_c *symbol);

   237     void *visit(il_fb_call_c *symbol);

   238     void *visit(il_formal_funct_call_c *symbol);

   239 //  void *visit(il_operand_list_c *symbol);

   240     void *visit(simple_instr_list_c *symbol);

   241     void *visit(il_simple_instruction_c*symbol);

   242 //  void *visit(il_param_list_c *symbol);

   243 //  void *visit(il_param_assignment_c *symbol);

   244 //  void *visit(il_param_out_assignment_c *symbol);

   245 

   246     /*******************/

   247     /* B 2.2 Operators */

   248     /*******************/

   249     void *visit(LD_operator_c *symbol);

   250     void *visit(LDN_operator_c *symbol);

   251     void *visit(ST_operator_c *symbol);

   252     void *visit(STN_operator_c *symbol);

   253     void *visit(NOT_operator_c *symbol);

   254     void *visit(S_operator_c *symbol);

   255     void *visit(R_operator_c *symbol);

   256     void *visit(S1_operator_c *symbol);

   257     void *visit(R1_operator_c *symbol);

   258     void *visit(CLK_operator_c *symbol);

   259     void *visit(CU_operator_c *symbol);

   260     void *visit(CD_operator_c *symbol);

   261     void *visit(PV_operator_c *symbol);

   262     void *visit(IN_operator_c *symbol);

   263     void *visit(PT_operator_c *symbol);

   264     void *visit(AND_operator_c *symbol);

   265     void *visit(OR_operator_c *symbol);

   266     void *visit(XOR_operator_c *symbol);

   267     void *visit(ANDN_operator_c *symbol);

   268     void *visit(ORN_operator_c *symbol);

   269     void *visit(XORN_operator_c *symbol);

   270     void *visit(ADD_operator_c *symbol);

   271     void *visit(SUB_operator_c *symbol);

   272     void *visit(MUL_operator_c *symbol);

   273     void *visit(DIV_operator_c *symbol);

   274     void *visit(MOD_operator_c *symbol);

   275     void *visit(GT_operator_c *symbol);

   276     void *visit(GE_operator_c *symbol);

   277     void *visit(EQ_operator_c *symbol);

   278     void *visit(LT_operator_c *symbol);

   279     void *visit(LE_operator_c *symbol);

   280     void *visit(NE_operator_c *symbol);

   281     void *visit(CAL_operator_c *symbol);

   282     void *visit(CALC_operator_c *symbol);

   283     void *visit(CALCN_operator_c *symbol);

   284     void *visit(RET_operator_c *symbol);

   285     void *visit(RETC_operator_c *symbol);

   286     void *visit(RETCN_operator_c *symbol);

   287     void *visit(JMP_operator_c *symbol);

   288     void *visit(JMPC_operator_c *symbol);

   289     void *visit(JMPCN_operator_c *symbol);

   290     /* Symbol class handled together with function call checks */

   291     // void *visit(il_assign_operator_c *symbol, variable_name);

   292     /* Symbol class handled together with function call checks */

   293     // void *visit(il_assign_operator_c *symbol, option, variable_name);

   294 

   295 

   296     /***************************************/

   297     /* B.3 - Language ST (Structured Text) */

   298     /***************************************/

   299     /***********************/

   300     /* B 3.1 - Expressions */

   301     /***********************/

   302     void *visit(or_expression_c *symbol);

   303     void *visit(xor_expression_c *symbol);

   304     void *visit(and_expression_c *symbol);

   305     void *visit(equ_expression_c *symbol);

   306     void *visit(notequ_expression_c *symbol);

   307     void *visit(lt_expression_c *symbol);

   308     void *visit(gt_expression_c *symbol);

   309     void *visit(le_expression_c *symbol);

   310     void *visit(ge_expression_c *symbol);

   311     void *visit(add_expression_c *symbol);

   312     void *visit(sub_expression_c *symbol);

   313     void *visit(mul_expression_c *symbol);

   314     void *visit(div_expression_c *symbol);

   315     void *visit(mod_expression_c *symbol);

   316     void *visit(power_expression_c *symbol);

   317     void *visit(neg_expression_c *symbol);

   318     void *visit(not_expression_c *symbol);

   319     void *visit(function_invocation_c *symbol);

   320 

   321     /*********************************/

   322     /* B 3.2.1 Assignment Statements */

   323     /*********************************/

   324     void *visit(assignment_statement_c *symbol);

   325 

   326     /*****************************************/

   327     /* B 3.2.2 Subprogram Control Statements */

   328     /*****************************************/

   329     void *visit(fb_invocation_c *symbol);

   330 

   331     /********************************/

   332     /* B 3.2.3 Selection Statements */

   333     /********************************/

   334     void *visit(if_statement_c *symbol);

   335     //     void *visit(elseif_statement_list_c *symbol);

   336     void *visit(elseif_statement_c *symbol);

   337     void *visit(case_statement_c *symbol);

   338 

   339     /********************************/

   340     /* B 3.2.4 Iteration Statements */

   341     /********************************/

   342     void *visit(for_statement_c *symbol);

   343     void *visit(while_statement_c *symbol);

   344     void *visit(repeat_statement_c *symbol);

   345 

   346 }; // fill_candidate_datatypes_c

   347 

   348 

   349 

   350 

   351 

   352 

   353 

   354 

   355 

   356 

   357