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_var_instance_decl_c *search_var_instance_decl;

    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 Function, FB, or Program currently being analysed */

    82

    symbol_c *current_scope;

    83

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

    84

    symbol_c *prev_il_instruction;

    85

    /* the current IL operand being analyzed */

    86

    symbol_c *il_operand;

    87

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

    88

    89

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

    90

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

    91

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

    92

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

    93

    void  handle_function_call(symbol_c *fcall, generic_function_call_t fcall_data);

    94

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

    95

    void *handle_S_and_R_operator   (symbol_c *symbol,         const char *operator_str, symbol_c *&called_fb_declaration);

    96

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

    97

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

    98

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

    99

    void *handle_conditional_il_flow_control_operator   (symbol_c *symbol);

   100

    void *fill_type_decl            (symbol_c *symbol,   symbol_c *type_name, symbol_c *spec_init);

   101

    void *fill_spec_init            (symbol_c *symbol,   symbol_c *type_spec, symbol_c *init_value);

   102

    void *fill_var_declaration      (symbol_c *var_list, symbol_c *type);

   103

   104

    /* a helper function... */

   105

    symbol_c *base_type(symbol_c *symbol);    

   106

   107

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

   108

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

   109

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

   110

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

   111

    void remove_incompatible_datatypes(symbol_c *symbol);

   112

   113

   114

  public:

   115

    fill_candidate_datatypes_c(symbol_c *ignore);

   116

    virtual ~fill_candidate_datatypes_c(void);

   117

   118

   119

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

   120

    /* B 0 - Programming Model */

   121

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

   122

    void *visit(library_c *symbol);

   123

   124

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

   125

    /* B.1 - Common elements */

   126

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

   127

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

   128

    /* B 1.1 - Letters, digits and identifiers */

   129

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

   130

//  void *visit(                 identifier_c *symbol);

   131

    void *visit(derived_datatype_identifier_c *symbol);

   132

//  void *visit(         poutype_identifier_c *symbol);

   133

   134

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

   135

    /* B 1.2 - Constants */

   136

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

   137

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

   138

    /* B 1.2.XX - Reference Literals */

   139

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

   140

    /* defined in IEC 61131-3 v3 - Basically the 'NULL' keyword! */

   141

    void *visit(ref_value_null_literal_c *symbol);

   142

   143

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

   144

    /* B 1.2.1 - Numeric Literals */

   145

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

   146

    void *handle_any_integer(symbol_c *symbol);

   147

    void *handle_any_real   (symbol_c *symbol);

   148

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

   149

   150

    void *visit(real_c *symbol);

   151

    void *visit(integer_c *symbol);

   152

    void *visit(neg_real_c *symbol);

   153

    void *visit(neg_integer_c *symbol);

   154

    void *visit(binary_integer_c *symbol);

   155

    void *visit(octal_integer_c *symbol);

   156

    void *visit(hex_integer_c *symbol);

   157

    void *visit(integer_literal_c *symbol);

   158

    void *visit(real_literal_c *symbol);

   159

    void *visit(bit_string_literal_c *symbol);

   160

    void *visit(boolean_literal_c *symbol);

   161

    void *visit(boolean_true_c *symbol);

   162

    void *visit(boolean_false_c *symbol);

   163

   164

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

   165

    /* B.1.2.2   Character Strings */

   166

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

   167

    void *visit(double_byte_character_string_c *symbol);

   168

    void *visit(single_byte_character_string_c *symbol);

   169

   170

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

   171

    /* B 1.2.3 - Time Literals */

   172

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

   173

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

   174

    /* B 1.2.3.1 - Duration */

   175

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

   176

    void *visit(duration_c *symbol);

   177

   178

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

   179

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

   180

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

   181

    void *visit(time_of_day_c *symbol);

   182

    void *visit(date_c *symbol);

   183

    void *visit(date_and_time_c *symbol);

   184

   185

   186

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

   187

    /* B 1.3 - Data types */

   188

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

   189

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

   190

    /* B 1.3.3 - Derived data types */

   191

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

   192

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

   193

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

   194

    void *visit(simple_type_declaration_c *symbol);

   195

    void *visit(simple_spec_init_c *symbol);

   196

    void *visit(subrange_type_declaration_c *symbol);

   197

    void *visit(subrange_spec_init_c *symbol);

   198

//  void *visit(subrange_specification_c *symbol);

   199

    void *visit(subrange_c *symbol);

   200

    void *visit(enumerated_type_declaration_c *symbol);

   201

    void *visit(enumerated_spec_init_c *symbol);

   202

    void *visit(enumerated_value_list_c *symbol);

   203

    void *visit(enumerated_value_c *symbol);

   204

    void *visit(array_type_declaration_c *symbol);

   205

    void *visit(array_spec_init_c *symbol);

   206

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

   207

//  void *visit(array_subrange_list_c *symbol);

   208

//  void *visit(array_initial_elements_list_c *symbol);

   209

//  void *visit(array_initial_elements_c *symbol);

   210

    void *visit(structure_type_declaration_c *symbol);

   211

    void *visit(initialized_structure_c *symbol);

   212

//  void *visit(structure_element_declaration_list_c *symbol);

   213

//  void *visit(structure_element_declaration_c *symbol);

   214

    void *visit(structure_element_initialization_list_c *symbol);

   215

    void *visit(structure_element_initialization_c *symbol);

   216

//  void *visit(string_type_declaration_c *symbol);

   217

    void *visit(fb_spec_init_c *symbol);

   218

   219

    void *visit(ref_spec_c *symbol);      // Defined in IEC 61131-3 v3

   220

    void *visit(ref_spec_init_c *symbol); // Defined in IEC 61131-3 v3

   221

    void *visit(ref_type_decl_c *symbol); // Defined in IEC 61131-3 v3

   222

   223

   224

   225

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

   226

    /* B 1.4 - Variables */

   227

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

   228

    void *visit(symbolic_variable_c *symbol);

   229

   230

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

   231

    /* B 1.4.1 - Directly Represented Variables */

   232

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

   233

    void *visit(direct_variable_c *symbol);

   234

   235

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

   236

    /* B 1.4.2 - Multi-element variables */

   237

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

   238

    void *visit(array_variable_c *symbol);

   239

    void *visit(structured_variable_c *symbol);

   240

   241

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

   242

    /* B 1.4.3 - Declaration & Initialisation */

   243

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

   244

    void *visit(var1_list_c                  *symbol);

   245

    void *visit(location_c                   *symbol);

   246

    void *visit(located_var_decl_c           *symbol);

   247

    void *visit(var1_init_decl_c             *symbol);

   248

    void *visit(array_var_init_decl_c        *symbol);

   249

    void *visit(structured_var_init_decl_c   *symbol);

   250

    void *visit(fb_name_decl_c               *symbol);

   251

    void *visit(array_var_declaration_c      *symbol);

   252

    void *visit(structured_var_declaration_c *symbol);

   253

    void *visit(external_declaration_c       *symbol);

   254

    void *visit(global_var_decl_c            *symbol);

   255

    void *visit(incompl_located_var_decl_c   *symbol);

   256

    //void *visit(single_byte_string_var_declaration_c *symbol);

   257

    //void *visit(double_byte_string_var_declaration_c *symbol);

   258

   259

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

   260

    /* B 1.5 - Program organization units */

   261

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

   262

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

   263

    /* B 1.5.1 - Functions */

   264

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

   265

    void *visit(function_declaration_c *symbol);

   266

   267

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

   268

    /* B 1.5.2 - Function blocks */

   269

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

   270

    void *visit(function_block_declaration_c *symbol);

   271

   272

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

   273

    /* B 1.5.3 - Programs */

   274

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

   275

    void *visit(program_declaration_c *symbol);

   276

   277

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

   278

    /* B 1.6 Sequential function chart elements */

   279

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

   280

    void *visit(transition_condition_c *symbol);

   281

   282

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

   283

    /* B 1.7 Configuration elements */

   284

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

   285

    void *visit(configuration_declaration_c   *symbol);

   286

    void *visit(resource_declaration_c        *symbol);

   287

    void *visit(single_resource_declaration_c *symbol);

   288

   289

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

   290

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

   291

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

   292

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

   293

    /* B 2.1 Instructions and Operands */

   294

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

   295

    void *visit(instruction_list_c *symbol);

   296

    void *visit(il_instruction_c *symbol);

   297

    void *visit(il_simple_operation_c *symbol);

   298

    void *visit(il_function_call_c *symbol);

   299

    void *visit(il_expression_c *symbol);

   300

    void *visit(il_jump_operation_c *symbol);

   301

    void *visit(il_fb_call_c *symbol);

   302

    void *visit(il_formal_funct_call_c *symbol);

   303

//  void *visit(il_operand_list_c *symbol);

   304

    void *visit(simple_instr_list_c *symbol);

   305

    void *visit(il_simple_instruction_c*symbol);

   306

//  void *visit(il_param_list_c *symbol);

   307

//  void *visit(il_param_assignment_c *symbol);

   308

//  void *visit(il_param_out_assignment_c *symbol);

   309

   310

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

   311

    /* B 2.2 Operators */

   312

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

   313

    void *visit(LD_operator_c *symbol);

   314

    void *visit(LDN_operator_c *symbol);

   315

    void *visit(ST_operator_c *symbol);

   316

    void *visit(STN_operator_c *symbol);

   317

    void *visit(NOT_operator_c *symbol);

   318

    void *visit(S_operator_c *symbol);

   319

    void *visit(R_operator_c *symbol);

   320

    void *visit(S1_operator_c *symbol);

   321

    void *visit(R1_operator_c *symbol);

   322

    void *visit(CLK_operator_c *symbol);

   323

    void *visit(CU_operator_c *symbol);

   324

    void *visit(CD_operator_c *symbol);

   325

    void *visit(PV_operator_c *symbol);

   326

    void *visit(IN_operator_c *symbol);

   327

    void *visit(PT_operator_c *symbol);

   328

    void *visit(AND_operator_c *symbol);

   329

    void *visit(OR_operator_c *symbol);

   330

    void *visit(XOR_operator_c *symbol);

   331

    void *visit(ANDN_operator_c *symbol);

   332

    void *visit(ORN_operator_c *symbol);

   333

    void *visit(XORN_operator_c *symbol);

   334

    void *visit(ADD_operator_c *symbol);

   335

    void *visit(SUB_operator_c *symbol);

   336

    void *visit(MUL_operator_c *symbol);

   337

    void *visit(DIV_operator_c *symbol);

   338

    void *visit(MOD_operator_c *symbol);

   339

    void *visit(GT_operator_c *symbol);

   340

    void *visit(GE_operator_c *symbol);

   341

    void *visit(EQ_operator_c *symbol);

   342

    void *visit(LT_operator_c *symbol);

   343

    void *visit(LE_operator_c *symbol);

   344

    void *visit(NE_operator_c *symbol);

   345

    void *visit(CAL_operator_c *symbol);

   346

    void *visit(CALC_operator_c *symbol);

   347

    void *visit(CALCN_operator_c *symbol);

   348

    void *visit(RET_operator_c *symbol);

   349

    void *visit(RETC_operator_c *symbol);

   350

    void *visit(RETCN_operator_c *symbol);

   351

    void *visit(JMP_operator_c *symbol);

   352

    void *visit(JMPC_operator_c *symbol);

   353

    void *visit(JMPCN_operator_c *symbol);

   354

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

   355

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

   356

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

   357

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

   358

   359

   360

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

   361

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

   362

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

   363

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

   364

    /* B 3.1 - Expressions */

   365

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

   366

    void *visit(   deref_operator_c   *symbol);

   367

    void *visit(   deref_expression_c *symbol);

   368

    void *visit(     ref_expression_c *symbol);

   369

    void *visit(      or_expression_c *symbol);

   370

    void *visit(     xor_expression_c *symbol);

   371

    void *visit(     and_expression_c *symbol);

   372

    void *visit(     equ_expression_c *symbol);

   373

    void *visit(  notequ_expression_c *symbol);

   374

    void *visit(      lt_expression_c *symbol);

   375

    void *visit(      gt_expression_c *symbol);

   376

    void *visit(      le_expression_c *symbol);

   377

    void *visit(      ge_expression_c *symbol);

   378

    void *visit(     add_expression_c *symbol);

   379

    void *visit(     sub_expression_c *symbol);

   380

    void *visit(     mul_expression_c *symbol);

   381

    void *visit(     div_expression_c *symbol);

   382

    void *visit(     mod_expression_c *symbol);

   383

    void *visit(   power_expression_c *symbol);

   384

    void *visit(     neg_expression_c *symbol);

   385

    void *visit(     not_expression_c *symbol);

   386

    void *visit(function_invocation_c *symbol);

   387

   388

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

   389

    /* B 3.2.1 Assignment Statements */

   390

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

   391

    void *visit(assignment_statement_c *symbol);

   392

   393

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

   394

    /* B 3.2.2 Subprogram Control Statements */

   395

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

   396

    void *visit(fb_invocation_c *symbol);

   397

   398

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

   399

    /* B 3.2.3 Selection Statements */

   400

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

   401

    void *visit(if_statement_c *symbol);

   402

    //     void *visit(elseif_statement_list_c *symbol);

   403

    void *visit(elseif_statement_c *symbol);

   404

    void *visit(case_statement_c *symbol);

   405

   406

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

   407

    /* B 3.2.4 Iteration Statements */

   408

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

   409

    void *visit(for_statement_c *symbol);

   410

    void *visit(while_statement_c *symbol);

   411

    void *visit(repeat_statement_c *symbol);

   412

   413

}; // fill_candidate_datatypes_c

   414

   415

   416

   417

   418

   419

   420

   421

   422

   423

   424