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

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

    57

     * by searching through the declarations of the variables currently

    58

     * in scope.

    59

     * This class does just that...

    60

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

    61

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

    62

     * This object instance will then later be called while the

    63

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

    64

     *

    65

     * Note that functions cannot contain calls to function blocks,

    66

     * so we do not create an object instance when handling

    67

     * a function declaration.

    68

     */

    69

    //     search_var_instance_decl_c *search_var_instance_decl;

    70

    71

    /* This variable was created to pass information from

    72

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

    73

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

    74

     */

    75

//     symbol_c *case_expression_type;

    76

    77

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

    78

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

    79

     * i.e. until the next LD.

    80

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

    81

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

    82

     * within parenthesis may not clear the error flag.

    83

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

    84

     * structure we are.

    85

     */

    86

//     int  il_parenthesis_level;

    87

//     bool error_found;

    88

    89

    /* This variable was created to pass information from

    90

     * fill_candidate_datatypes_c::visit(enumerated_spec_init_c *symbol) function to

    91

     * fill_candidate_datatypes_c::visit(enumerated_value_list_c *symbol) function.

    92

     */

    93

    symbol_c *current_enumerated_spec_type;

    94

    95

    /* 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 */

    96

    symbol_c *prev_il_instruction;

    97

    /* the current IL operand being analyzed */

    98

    symbol_c *il_operand;

    99

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

   100

   101

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

   102

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

   103

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

   104

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

   105

    void  handle_function_call(symbol_c *fcall, generic_function_call_t fcall_data);

   106

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

   107

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

   108

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

   109

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

   110

    void *handle_conditional_il_flow_control_operator(symbol_c *symbol);

   111

   112

    /* a helper function... */

   113

    symbol_c *base_type(symbol_c *symbol);    

   114

   115

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

   116

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

   117

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

   118

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

   119

    void remove_incompatible_datatypes(symbol_c *symbol);

   120

   121

   122

  public:

   123

    fill_candidate_datatypes_c(symbol_c *ignore);

   124

    virtual ~fill_candidate_datatypes_c(void);

   125

   126

   127

    /*********************/

   128

    /* B 1.2 - Constants */

   129

    /*********************/

   130

    /******************************/

   131

    /* B 1.2.1 - Numeric Literals */

   132

    /******************************/

   133

    void *handle_any_integer(symbol_c *symbol);

   134

    void *handle_any_real   (symbol_c *symbol);

   135

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

   136

   137

    void *visit(real_c *symbol);

   138

    void *visit(integer_c *symbol);

   139

    void *visit(neg_real_c *symbol);

   140

    void *visit(neg_integer_c *symbol);

   141

    void *visit(binary_integer_c *symbol);

   142

    void *visit(octal_integer_c *symbol);

   143

    void *visit(hex_integer_c *symbol);

   144

    void *visit(integer_literal_c *symbol);

   145

    void *visit(real_literal_c *symbol);

   146

    void *visit(bit_string_literal_c *symbol);

   147

    void *visit(boolean_literal_c *symbol);

   148

    void *visit(boolean_true_c *symbol);

   149

    void *visit(boolean_false_c *symbol);

   150

   151

    /*******************************/

   152

    /* B.1.2.2   Character Strings */

   153

    /*******************************/

   154

    void *visit(double_byte_character_string_c *symbol);

   155

    void *visit(single_byte_character_string_c *symbol);

   156

   157

    /***************************/

   158

    /* B 1.2.3 - Time Literals */

   159

    /***************************/

   160

    /************************/

   161

    /* B 1.2.3.1 - Duration */

   162

    /************************/

   163

    void *visit(duration_c *symbol);

   164

   165

    /************************************/

   166

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

   167

    /************************************/

   168

    void *visit(time_of_day_c *symbol);

   169

    void *visit(date_c *symbol);

   170

    void *visit(date_and_time_c *symbol);

   171

   172

   173

    /**********************/

   174

    /* B 1.3 - Data types */

   175

    /**********************/

   176

    /********************************/

   177

    /* B 1.3.3 - Derived data types */

   178

    /********************************/

   179

//  void *visit(data_type_declaration_c *symbol);   /* Not required. already handled by iterator_visitor_c base class */

   180

//  void *visit(type_declaration_list_c *symbol);   /* Not required. already handled by iterator_visitor_c base class */

   181

//  void *visit(simple_type_declaration_c *symbol); /* Not required. already handled by iterator_visitor_c base class */

   182

    void *visit(simple_spec_init_c *symbol);

   183

//  void *visit(subrange_type_declaration_c *symbol);

   184

//  void *visit(subrange_spec_init_c *symbol);

   185

//  void *visit(subrange_specification_c *symbol);

   186

    void *visit(subrange_c *symbol);

   187

//  void *visit(enumerated_type_declaration_c *symbol); /* Not required. already handled by iterator_visitor_c base class */

   188

    void *visit(enumerated_spec_init_c *symbol);

   189

    void *visit(enumerated_value_list_c *symbol);

   190

    void *visit(enumerated_value_c *symbol);

   191

//  void *visit(array_type_declaration_c *symbol);

   192

//  void *visit(array_spec_init_c *symbol);

   193

//  void *visit(array_specification_c *symbol);

   194

//  void *visit(array_subrange_list_c *symbol);

   195

//  void *visit(array_initial_elements_list_c *symbol);

   196

//  void *visit(array_initial_elements_c *symbol);

   197

//  void *visit(structure_type_declaration_c *symbol);

   198

//  void *visit(initialized_structure_c *symbol);

   199

//  void *visit(structure_element_declaration_list_c *symbol);

   200

//  void *visit(structure_element_declaration_c *symbol);

   201

//  void *visit(structure_element_initialization_list_c *symbol);

   202

//  void *visit(structure_element_initialization_c *symbol);

   203

//  void *visit(string_type_declaration_c *symbol);

   204

   205

   206

    /*********************/

   207

    /* B 1.4 - Variables */

   208

    /*********************/

   209

    void *visit(symbolic_variable_c *symbol);

   210

   211

    /********************************************/

   212

    /* B 1.4.1 - Directly Represented Variables */

   213

    /********************************************/

   214

    void *visit(direct_variable_c *symbol);

   215

   216

    /*************************************/

   217

    /* B 1.4.2 - Multi-element variables */

   218

    /*************************************/

   219

    void *visit(array_variable_c *symbol);

   220

    void *visit(structured_variable_c *symbol);

   221

   222

    /******************************************/

   223

    /* B 1.4.3 - Declaration & Initialisation */

   224

    /******************************************/

   225

    void *visit(var1_list_c *symbol);

   226

    void *visit(location_c *symbol);

   227

    void *visit(located_var_decl_c *symbol);

   228

   229

   230

    /**************************************/

   231

    /* B 1.5 - Program organization units */

   232

    /**************************************/

   233

    /***********************/

   234

    /* B 1.5.1 - Functions */

   235

    /***********************/

   236

    void *visit(function_declaration_c *symbol);

   237

   238

    /*****************************/

   239

    /* B 1.5.2 - Function blocks */

   240

    /*****************************/

   241

    void *visit(function_block_declaration_c *symbol);

   242

   243

    /**********************/

   244

    /* B 1.5.3 - Programs */

   245

    /**********************/

   246

    void *visit(program_declaration_c *symbol);

   247

   248

    /********************************/

   249

    /* B 1.7 Configuration elements */

   250

    /********************************/

   251

    void *visit(configuration_declaration_c *symbol);

   252

   253

    /****************************************/

   254

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

   255

    /****************************************/

   256

    /***********************************/

   257

    /* B 2.1 Instructions and Operands */

   258

    /***********************************/

   259

    void *visit(instruction_list_c *symbol);

   260

    void *visit(il_instruction_c *symbol);

   261

    void *visit(il_simple_operation_c *symbol);

   262

    void *visit(il_function_call_c *symbol);

   263

    void *visit(il_expression_c *symbol);

   264

    void *visit(il_jump_operation_c *symbol);

   265

    void *visit(il_fb_call_c *symbol);

   266

    void *visit(il_formal_funct_call_c *symbol);

   267

//  void *visit(il_operand_list_c *symbol);

   268

    void *visit(simple_instr_list_c *symbol);

   269

    void *visit(il_simple_instruction_c*symbol);

   270

//  void *visit(il_param_list_c *symbol);

   271

//  void *visit(il_param_assignment_c *symbol);

   272

//  void *visit(il_param_out_assignment_c *symbol);

   273

   274

    /*******************/

   275

    /* B 2.2 Operators */

   276

    /*******************/

   277

    void *visit(LD_operator_c *symbol);

   278

    void *visit(LDN_operator_c *symbol);

   279

    void *visit(ST_operator_c *symbol);

   280

    void *visit(STN_operator_c *symbol);

   281

    void *visit(NOT_operator_c *symbol);

   282

    void *visit(S_operator_c *symbol);

   283

    void *visit(R_operator_c *symbol);

   284

    void *visit(S1_operator_c *symbol);

   285

    void *visit(R1_operator_c *symbol);

   286

    void *visit(CLK_operator_c *symbol);

   287

    void *visit(CU_operator_c *symbol);

   288

    void *visit(CD_operator_c *symbol);

   289

    void *visit(PV_operator_c *symbol);

   290

    void *visit(IN_operator_c *symbol);

   291

    void *visit(PT_operator_c *symbol);

   292

    void *visit(AND_operator_c *symbol);

   293

    void *visit(OR_operator_c *symbol);

   294

    void *visit(XOR_operator_c *symbol);

   295

    void *visit(ANDN_operator_c *symbol);

   296

    void *visit(ORN_operator_c *symbol);

   297

    void *visit(XORN_operator_c *symbol);

   298

    void *visit(ADD_operator_c *symbol);

   299

    void *visit(SUB_operator_c *symbol);

   300

    void *visit(MUL_operator_c *symbol);

   301

    void *visit(DIV_operator_c *symbol);

   302

    void *visit(MOD_operator_c *symbol);

   303

    void *visit(GT_operator_c *symbol);

   304

    void *visit(GE_operator_c *symbol);

   305

    void *visit(EQ_operator_c *symbol);

   306

    void *visit(LT_operator_c *symbol);

   307

    void *visit(LE_operator_c *symbol);

   308

    void *visit(NE_operator_c *symbol);

   309

    void *visit(CAL_operator_c *symbol);

   310

    void *visit(CALC_operator_c *symbol);

   311

    void *visit(CALCN_operator_c *symbol);

   312

    void *visit(RET_operator_c *symbol);

   313

    void *visit(RETC_operator_c *symbol);

   314

    void *visit(RETCN_operator_c *symbol);

   315

    void *visit(JMP_operator_c *symbol);

   316

    void *visit(JMPC_operator_c *symbol);

   317

    void *visit(JMPCN_operator_c *symbol);

   318

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

   319

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

   320

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

   321

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

   322

   323

   324

    /***************************************/

   325

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

   326

    /***************************************/

   327

    /***********************/

   328

    /* B 3.1 - Expressions */

   329

    /***********************/

   330

    void *visit(or_expression_c *symbol);

   331

    void *visit(xor_expression_c *symbol);

   332

    void *visit(and_expression_c *symbol);

   333

    void *visit(equ_expression_c *symbol);

   334

    void *visit(notequ_expression_c *symbol);

   335

    void *visit(lt_expression_c *symbol);

   336

    void *visit(gt_expression_c *symbol);

   337

    void *visit(le_expression_c *symbol);

   338

    void *visit(ge_expression_c *symbol);

   339

    void *visit(add_expression_c *symbol);

   340

    void *visit(sub_expression_c *symbol);

   341

    void *visit(mul_expression_c *symbol);

   342

    void *visit(div_expression_c *symbol);

   343

    void *visit(mod_expression_c *symbol);

   344

    void *visit(power_expression_c *symbol);

   345

    void *visit(neg_expression_c *symbol);

   346

    void *visit(not_expression_c *symbol);

   347

    void *visit(function_invocation_c *symbol);

   348

   349

    /*********************************/

   350

    /* B 3.2.1 Assignment Statements */

   351

    /*********************************/

   352

    void *visit(assignment_statement_c *symbol);

   353

   354

    /*****************************************/

   355

    /* B 3.2.2 Subprogram Control Statements */

   356

    /*****************************************/

   357

    void *visit(fb_invocation_c *symbol);

   358

   359

    /********************************/

   360

    /* B 3.2.3 Selection Statements */

   361

    /********************************/

   362

    void *visit(if_statement_c *symbol);

   363

    //     void *visit(elseif_statement_list_c *symbol);

   364

    void *visit(elseif_statement_c *symbol);

   365

    void *visit(case_statement_c *symbol);

   366

   367

    /********************************/

   368

    /* B 3.2.4 Iteration Statements */

   369

    /********************************/

   370

    void *visit(for_statement_c *symbol);

   371

    void *visit(while_statement_c *symbol);

   372

    void *visit(repeat_statement_c *symbol);

   373

   374

}; // fill_candidate_datatypes_c

   375

   376

   377

   378

   379

   380

   381

   382

   383

   384

   385