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

 * WARNING: This visitor class starts off by building a map of all enumeration constants that are defined in the source code (i.e. a library_c symbol),

    48

 *          and this map is later used to determine the datatpe of each use of an enumeration constant. By implication, the fill_candidate_datatypes_c 

    49

 *          visitor class will only work corretly if it is asked to visit a symbol of class library_c!!

    50

 */

    51

    52

    53

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

    54

#include "datatype_functions.hh"

    55

    56

class fill_candidate_datatypes_c: public iterator_visitor_c {

    57

    58

  private:

    59

    search_varfb_instance_type_c *search_varfb_instance_type;

    60

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

    61

     * by searching through the declarations of the variables currently

    62

     * in scope.

    63

     * This class does just that...

    64

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

    65

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

    66

     * This object instance will then later be called while the

    67

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

    68

     *

    69

     * Note that functions cannot contain calls to function blocks,

    70

     * so we do not create an object instance when handling

    71

     * a function declaration.

    72

     */

    73

    //     search_var_instance_decl_c *search_var_instance_decl;

    74

    75

    /* This variable was created to pass information from

    76

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

    77

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

    78

     */

    79

    symbol_c *current_enumerated_spec_type;

    80

    81

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

    82

    symbol_c *prev_il_instruction;

    83

    /* the current IL operand being analyzed */

    84

    symbol_c *il_operand;

    85

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

    86

    87

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

    88

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

    89

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

    90

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

    91

    void  handle_function_call(symbol_c *fcall, generic_function_call_t fcall_data);

    92

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

    93

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

    94

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

    95

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

    96

    void *handle_conditional_il_flow_control_operator(symbol_c *symbol);

    97

    98

    /* a helper function... */

    99

    symbol_c *base_type(symbol_c *symbol);    

   100

   101

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

   102

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

   103

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

   104

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

   105

    void remove_incompatible_datatypes(symbol_c *symbol);

   106

   107

   108

  public:

   109

    fill_candidate_datatypes_c(symbol_c *ignore);

   110

    virtual ~fill_candidate_datatypes_c(void);

   111

   112

   113

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

   114

    /* B 0 - Programming Model */

   115

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

   116

    void *visit(library_c *symbol);

   117

   118

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

   119

    /* B 1.2 - Constants */

   120

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

   121

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

   122

    /* B 1.2.1 - Numeric Literals */

   123

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

   124

    void *handle_any_integer(symbol_c *symbol);

   125

    void *handle_any_real   (symbol_c *symbol);

   126

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

   127

   128

    void *visit(real_c *symbol);

   129

    void *visit(integer_c *symbol);

   130

    void *visit(neg_real_c *symbol);

   131

    void *visit(neg_integer_c *symbol);

   132

    void *visit(binary_integer_c *symbol);

   133

    void *visit(octal_integer_c *symbol);

   134

    void *visit(hex_integer_c *symbol);

   135

    void *visit(integer_literal_c *symbol);

   136

    void *visit(real_literal_c *symbol);

   137

    void *visit(bit_string_literal_c *symbol);

   138

    void *visit(boolean_literal_c *symbol);

   139

    void *visit(boolean_true_c *symbol);

   140

    void *visit(boolean_false_c *symbol);

   141

   142

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

   143

    /* B.1.2.2   Character Strings */

   144

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

   145

    void *visit(double_byte_character_string_c *symbol);

   146

    void *visit(single_byte_character_string_c *symbol);

   147

   148

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

   149

    /* B 1.2.3 - Time Literals */

   150

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

   151

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

   152

    /* B 1.2.3.1 - Duration */

   153

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

   154

    void *visit(duration_c *symbol);

   155

   156

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

   157

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

   158

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

   159

    void *visit(time_of_day_c *symbol);

   160

    void *visit(date_c *symbol);

   161

    void *visit(date_and_time_c *symbol);

   162

   163

   164

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

   165

    /* B 1.3 - Data types */

   166

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

   167

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

   168

    /* B 1.3.3 - Derived data types */

   169

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

   170

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

   171

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

   172

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

   173

    void *visit(simple_spec_init_c *symbol);

   174

//  void *visit(subrange_type_declaration_c *symbol);

   175

//  void *visit(subrange_spec_init_c *symbol);

   176

//  void *visit(subrange_specification_c *symbol);

   177

    void *visit(subrange_c *symbol);

   179

    void *visit(enumerated_spec_init_c *symbol);

   180

    void *visit(enumerated_value_list_c *symbol);

   181

    void *visit(enumerated_value_c *symbol);

   182

//  void *visit(array_type_declaration_c *symbol);

   183

//  void *visit(array_spec_init_c *symbol);

   184

//  void *visit(array_specification_c *symbol);

   185

//  void *visit(array_subrange_list_c *symbol);

   186

//  void *visit(array_initial_elements_list_c *symbol);

   187

//  void *visit(array_initial_elements_c *symbol);

   188

//  void *visit(structure_type_declaration_c *symbol);

   189

//  void *visit(initialized_structure_c *symbol);

   190

//  void *visit(structure_element_declaration_list_c *symbol);

   191

//  void *visit(structure_element_declaration_c *symbol);

   192

//  void *visit(structure_element_initialization_list_c *symbol);

   193

//  void *visit(structure_element_initialization_c *symbol);

   194

//  void *visit(string_type_declaration_c *symbol);

   195

   196

   197

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

   198

    /* B 1.4 - Variables */

   199

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

   200

    void *visit(symbolic_variable_c *symbol);

   201

   202

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

   203

    /* B 1.4.1 - Directly Represented Variables */

   204

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

   205

    void *visit(direct_variable_c *symbol);

   206

   207

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

   208

    /* B 1.4.2 - Multi-element variables */

   209

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

   210

    void *visit(array_variable_c *symbol);

   211

    void *visit(structured_variable_c *symbol);

   212

   213

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

   214

    /* B 1.4.3 - Declaration & Initialisation */

   215

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

   216

    void *visit(var1_list_c *symbol);

   217

    void *visit(location_c *symbol);

   218

    void *visit(located_var_decl_c *symbol);

   219

   220

   221

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

   222

    /* B 1.5 - Program organization units */

   223

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

   224

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

   225

    /* B 1.5.1 - Functions */

   226

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

   227

    void *visit(function_declaration_c *symbol);

   228

   229

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

   230

    /* B 1.5.2 - Function blocks */

   231

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

   232

    void *visit(function_block_declaration_c *symbol);

   233

   234

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

   235

    /* B 1.5.3 - Programs */

   236

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

   237

    void *visit(program_declaration_c *symbol);

   238

   239

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

   240

    /* B 1.7 Configuration elements */

   241

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

   242

    void *visit(configuration_declaration_c *symbol);

   243

   244

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

   245

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

   246

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

   247

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

   248

    /* B 2.1 Instructions and Operands */

   249

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

   250

    void *visit(instruction_list_c *symbol);

   251

    void *visit(il_instruction_c *symbol);

   252

    void *visit(il_simple_operation_c *symbol);

   253

    void *visit(il_function_call_c *symbol);

   254

    void *visit(il_expression_c *symbol);

   255

    void *visit(il_jump_operation_c *symbol);

   256

    void *visit(il_fb_call_c *symbol);

   257

    void *visit(il_formal_funct_call_c *symbol);

   258

//  void *visit(il_operand_list_c *symbol);

   259

    void *visit(simple_instr_list_c *symbol);

   260

    void *visit(il_simple_instruction_c*symbol);

   261

//  void *visit(il_param_list_c *symbol);

   262

//  void *visit(il_param_assignment_c *symbol);

   263

//  void *visit(il_param_out_assignment_c *symbol);

   264

   265

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

   266

    /* B 2.2 Operators */

   267

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

   268

    void *visit(LD_operator_c *symbol);

   269

    void *visit(LDN_operator_c *symbol);

   270

    void *visit(ST_operator_c *symbol);

   271

    void *visit(STN_operator_c *symbol);

   272

    void *visit(NOT_operator_c *symbol);

   273

    void *visit(S_operator_c *symbol);

   274

    void *visit(R_operator_c *symbol);

   275

    void *visit(S1_operator_c *symbol);

   276

    void *visit(R1_operator_c *symbol);

   277

    void *visit(CLK_operator_c *symbol);

   278

    void *visit(CU_operator_c *symbol);

   279

    void *visit(CD_operator_c *symbol);

   280

    void *visit(PV_operator_c *symbol);

   281

    void *visit(IN_operator_c *symbol);

   282

    void *visit(PT_operator_c *symbol);

   283

    void *visit(AND_operator_c *symbol);

   284

    void *visit(OR_operator_c *symbol);

   285

    void *visit(XOR_operator_c *symbol);

   286

    void *visit(ANDN_operator_c *symbol);

   287

    void *visit(ORN_operator_c *symbol);

   288

    void *visit(XORN_operator_c *symbol);

   289

    void *visit(ADD_operator_c *symbol);

   290

    void *visit(SUB_operator_c *symbol);

   291

    void *visit(MUL_operator_c *symbol);

   292

    void *visit(DIV_operator_c *symbol);

   293

    void *visit(MOD_operator_c *symbol);

   294

    void *visit(GT_operator_c *symbol);

   295

    void *visit(GE_operator_c *symbol);

   296

    void *visit(EQ_operator_c *symbol);

   297

    void *visit(LT_operator_c *symbol);

   298

    void *visit(LE_operator_c *symbol);

   299

    void *visit(NE_operator_c *symbol);

   300

    void *visit(CAL_operator_c *symbol);

   301

    void *visit(CALC_operator_c *symbol);

   302

    void *visit(CALCN_operator_c *symbol);

   303

    void *visit(RET_operator_c *symbol);

   304

    void *visit(RETC_operator_c *symbol);

   305

    void *visit(RETCN_operator_c *symbol);

   306

    void *visit(JMP_operator_c *symbol);

   307

    void *visit(JMPC_operator_c *symbol);

   308

    void *visit(JMPCN_operator_c *symbol);

   309

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

   310

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

   311

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

   312

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

   313

   314

   315

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

   316

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

   317

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

   318

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

   319

    /* B 3.1 - Expressions */

   320

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

   321

    void *visit(or_expression_c *symbol);

   322

    void *visit(xor_expression_c *symbol);

   323

    void *visit(and_expression_c *symbol);

   324

    void *visit(equ_expression_c *symbol);

   325

    void *visit(notequ_expression_c *symbol);

   326

    void *visit(lt_expression_c *symbol);

   327

    void *visit(gt_expression_c *symbol);

   328

    void *visit(le_expression_c *symbol);

   329

    void *visit(ge_expression_c *symbol);

   330

    void *visit(add_expression_c *symbol);

   331

    void *visit(sub_expression_c *symbol);

   332

    void *visit(mul_expression_c *symbol);

   333

    void *visit(div_expression_c *symbol);

   334

    void *visit(mod_expression_c *symbol);

   335

    void *visit(power_expression_c *symbol);

   336

    void *visit(neg_expression_c *symbol);

   337

    void *visit(not_expression_c *symbol);

   338

    void *visit(function_invocation_c *symbol);

   339

   340

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

   341

    /* B 3.2.1 Assignment Statements */

   342

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

   343

    void *visit(assignment_statement_c *symbol);

   344

   345

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

   346

    /* B 3.2.2 Subprogram Control Statements */

   347

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

   348

    void *visit(fb_invocation_c *symbol);

   349

   350

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

   351

    /* B 3.2.3 Selection Statements */

   352

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

   353

    void *visit(if_statement_c *symbol);

   354

    //     void *visit(elseif_statement_list_c *symbol);

   355

    void *visit(elseif_statement_c *symbol);

   356

    void *visit(case_statement_c *symbol);

   357

   358

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

   359

    /* B 3.2.4 Iteration Statements */

   360

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

   361

    void *visit(for_statement_c *symbol);

   362

    void *visit(while_statement_c *symbol);

   363

    void *visit(repeat_statement_c *symbol);

   364

   365

}; // fill_candidate_datatypes_c

   366

   367

   368

   369

   370

   371

   372

   373

   374

   375

   376