1

/*

     2

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

     3

 *

     4

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

     5

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6

 *

     7

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

     8

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

     9

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

    10

 *  (at your option) any later version.

    11

 *

    12

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

    13

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

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

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

    18

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

    19

 *

    20

 *

    21

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

    22

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

    23

 */

    24

    25

/*

    26

 * An IEC 61131-3 compiler.

    27

 *

    28

 * Based on the

    29

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

    30

 *

    31

 */

    32

    33

/* Determine the data type of a variable.

    34

 * The variable may be a simple variable, a function block instance, a

    35

 * struture element within a data structured type (a struct or a fb), or

    36

 * an array element.

    37

 * A mixture of array element of a structure element of a structure element

    38

 * of a .... is also suported!

    39

 *

    40

 *  example:

    41

 *    window.points[1].coordinate.x

    42

 *    window.points[1].colour

    43

 *    etc... ARE ALLOWED!

    44

 *

    45

 * This class must be passed the scope within which the

    46

 * variable was declared, and the variable name...

    47

 *

    48

 *

    49

 *

    50

 *

    51

 *

    52

 * This class has several members, depending on the exact data the caller

    53

 * is looking for...

    54

 *

    55

 *    - item i: we can get either the name of the data type(A),

    56

 *              or it's declaration (B)

    57

 *             (notice however that some variables belong to a data type that does

    58

 *              not have a name, only a declaration as in

    59

 *              VAR a: ARRAY [1..3] of INT; END_VAR

    60

 *             )

    61

 *    - item ii: we can get either the direct data type (1), 

    62

 *               or the base type (2)

    63

 * 

    64

 *   By direct type, I mean the data type of the variable. By base type, I 

    65

 * mean the data type on which the direct type is based on. For example, in 

    66

 * a subrange on INT, the direct type is the subrange itself, while the 

    67

 * base type is INT.

    68

 * e.g.

    69

 *   This means that if we find that the variable is of type MY_INT,

    70

 *   which was previously declared to be

    71

 *   TYPE MY_INT: INT := 9;

    72

 *   option (1) will return MY_INT

    73

 *   option (2) will return INT

    74

 * 

    75

 *

    76

 * Member functions:

    77

 * ================

    78

 *   get_basetype_id()    ---> returns 2A   (implemented, although currently it is not needed! )

    79

 *   get_basetype_decl()  ---> returns 2B 

    80

 *   get_type_id()        ---> returns 1A

    81

 * 

    82

 *   Since we haven't yet needed it, we don't yet implement

    83

 *   get_type_decl()      ---> returns 1B 

    84

 */ 

    85

    86

    87

    88

#include "absyntax_utils.hh"

    89

    90

    91

void search_varfb_instance_type_c::init(void) {

    92

  this->current_type_id        = NULL;

    93

  this->current_basetype_id    = NULL;

    94

  this->current_basetype_decl  = NULL;

    95

  this->current_field_selector = NULL;

    96

}

    97

    98

    99

search_varfb_instance_type_c::search_varfb_instance_type_c(symbol_c *search_scope): search_var_instance_decl(search_scope) {

   100

  this->init();

   101

}

   102

   103

   104

/* We expect to be passed a symbolic_variable_c */

   105

symbol_c *search_varfb_instance_type_c::get_type_id(symbol_c *variable_name) {

   106

  this->init();

   107

  variable_name->accept(*this);

   108

  return current_type_id;

   109

}

   110

   111

   112

symbol_c *search_varfb_instance_type_c::get_basetype_id(symbol_c *variable_name) {

   113

  this->init();

   114

  variable_name->accept(*this);

   115

  return current_basetype_id;

   116

}

   117

   118

   119

symbol_c *search_varfb_instance_type_c::get_basetype_decl(symbol_c *variable_name) {

   120

  this->init();

   121

  variable_name->accept(*this);

   122

  return current_basetype_decl;

   123

}  

   124

   125

   126

   127

   128

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

   129

/* B.1 - Common elements */

   130

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

   131

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

   132

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

   133

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

   134

// SYM_TOKEN(identifier_c)

   135

void *search_varfb_instance_type_c::visit(identifier_c *variable_name) {

   136

  /* symbol should be a variable name!! */

   137

  /* Note: although the method is called get_decl(), it is getting the declaration of the variable, which for us is the type_id of that variable! */

   138

  current_type_id       = search_var_instance_decl.get_decl (variable_name);

   139

  current_basetype_decl = search_base_type_c::get_basetype_decl(current_type_id);

   140

  current_basetype_id   = search_base_type_c::get_basetype_id  (current_type_id);

   141

   142

  /* What if the variable has not been declared?  Then this should not be a compiler error! 

   143

   * However, currently stage 2 of the compiler already detects when variables have not been delcared,

   144

   * so if the variable's declaration is not found, then that means that we have an internal compiler error!

   145

   * 

   146

   * Actually, the above is not true anymore. See the use of the any_symbolic_variable in iec_bison.yy

   147

   *  - when defining the delay of a delayed action association in SFC

   148

   *  - in program connections inside configurations (will this search_varfb_instance_type_c class be called to handle this??)

   149

   */

   150

  // if (NULL == current_type_id) ERROR; 

   151

   152

  return NULL;

   153

}

   154

   155

   156

   157

   158

   159

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

   160

/* B 1.3.3 - Derived data types */

   161

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

   162

/*  identifier ':' array_spec_init */

   163

/* NOTE: I don't think this will ever get called, since in the visit method for array_variable_c

   164

 * we use the basetype_decl for recursively calling this class, and the base type should never be a 

   165

 * array_type_declaration_c, but for now, let's leave it in...

   166

 */

   167

void *search_varfb_instance_type_c::visit(array_type_declaration_c *symbol) {

   168

  ERROR;

   169

  return NULL;

   170

}

   171

   172

/* array_specification [ASSIGN array_initialization] */

   173

/* array_initialization may be NULL ! */

   174

/* NOTE: I don't think this will ever get called, since in the visit method for array_variable_c

   175

 * we use the basetype_decl for recursively calling this class, and the base type should never be a 

   176

 * array_spec_init_c, but for now, let's leave it in...

   177

 */

   178

void *search_varfb_instance_type_c::visit(array_spec_init_c *symbol) {

   179

  /* Note that the 'array_specification' may be either an identifier of a previsously defined array type, 

   180

   * or an array_specification_c, so we can not stop here and simply return a array_spec_init_c, 

   181

   * especially if we are looking for the base class!

   182

   */

   183

  ERROR;

   184

  return NULL;

   185

}

   186

   187

/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */

   188

/* NOTE: This method will be reached after being called from the 

   189

 * search_varfb_instance_type_c::visit(array_variable_c *symbol)

   190

 * method, so we must return the data type of the data stored in the array, 

   191

 * and not the data type of the array itself!

   192

 */

   193

void *search_varfb_instance_type_c::visit(array_specification_c *symbol) {

   194

  /* found the type of the element we were looking for! */

   195

  current_type_id       = symbol->non_generic_type_name;

   196

  current_basetype_decl = search_base_type_c::get_basetype_decl(current_type_id);

   197

  current_basetype_id   = search_base_type_c::get_basetype_id  (current_type_id);

   198

   199

  return NULL; 

   200

}

   201

   202

   203

/*  structure_type_name ':' structure_specification */

   204

/* NOTE: this is only used inside a TYPE ... END_TYPE declaration. 

   205

 * It is never used directly when declaring a new variable! 

   206

 */

   207

/* NOTE: I don't think this will ever get called, since in the visit method for structured_variable_c

   208

 * we use the basetype_decl for recursively calling this class, and the base type should never be a 

   209

 * structure_type_declaration_c, but for now, let's leave it in...

   210

 */

   211

void *search_varfb_instance_type_c::visit(structure_type_declaration_c *symbol) {

   212

  if (NULL == current_field_selector) return NULL; // the source code has a datatype consistency bug that will be caught later!!

   213

   214

  symbol->structure_specification->accept(*this);

   215

  return NULL;

   216

  /* NOTE: structure_specification will point to either a

   217

   *       initialized_structure_c

   218

   *       OR A

   219

   *       structure_element_declaration_list_c

   220

   */

   221

}

   222

   223

/* structure_type_name ASSIGN structure_initialization */

   224

/* structure_initialization may be NULL ! */

   225

// SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization)

   226

/* NOTE: only the initialized structure is never used when declaring a new variable instance */

   227

/* NOTE: I don't think this will ever get called, since in the visit method for structured_variable_c

   228

 * we use the basetype_decl for recursively calling this class, and the base type should never be a 

   229

 * initialized_structure_c, but for now, let's leave it in...

   230

 */

   231

void *search_varfb_instance_type_c::visit(initialized_structure_c *symbol)	{

   232

  if (NULL == current_field_selector) return NULL; // the source code has a datatype consistency bug that will be caught later!!

   233

   234

  /* recursively find out the data type of current_field_selector... */

   235

  symbol->structure_type_name->accept(*this);

   236

  return NULL;

   237

}

   238

   239

/* helper symbol for structure_declaration */

   240

/* structure_declaration:  STRUCT structure_element_declaration_list END_STRUCT */

   241

/* structure_element_declaration_list structure_element_declaration ';' */

   242

void *search_varfb_instance_type_c::visit(structure_element_declaration_list_c *symbol)	{

   243

  if (NULL == current_field_selector) return NULL; // the source code has a datatype consistency bug that will be caught later!!

   244

   245

  /* now search the structure declaration */

   246

  for(int i = 0; i < symbol->n; i++) {

   247

    symbol->get_element(i)->accept(*this);

   248

  }

   249

   250

  return NULL;

   251

}

   252

   253

/*  structure_element_name ':' spec_init */

   254

void *search_varfb_instance_type_c::visit(structure_element_declaration_c *symbol) {

   255

  if (NULL == current_field_selector) return NULL; // the source code has a datatype consistency bug that will be caught later!!

   256

   257

  if (compare_identifiers(symbol->structure_element_name, current_field_selector) == 0) {

   258

    /* found the type of the element we were looking for! */

   259

    current_type_id       = symbol->spec_init;

   260

    current_basetype_decl = search_base_type_c::get_basetype_decl(current_type_id);

   261

    current_basetype_id   = search_base_type_c::get_basetype_id  (current_type_id);

   262

  }  

   263

   264

  /* Did not find the type of the element we were looking for! */

   265

  /* Will keep looking... */

   266

  return NULL;

   267

}

   268

   269

/* helper symbol for structure_initialization */

   270

/* structure_initialization: '(' structure_element_initialization_list ')' */

   271

/* structure_element_initialization_list ',' structure_element_initialization */

   272

void *search_varfb_instance_type_c::visit(structure_element_initialization_list_c *symbol) {ERROR; return NULL;} /* should never get called... */

   273

/*  structure_element_name ASSIGN value */

   274

void *search_varfb_instance_type_c::visit(structure_element_initialization_c *symbol) {ERROR; return NULL;} /* should never get called... */

   275

   276

   277

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

   278

/* B 1.4 - Variables */

   279

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

   280

// SYM_REF1(symbolic_variable_c, var_name)

   281

void *search_varfb_instance_type_c::visit(symbolic_variable_c *symbol) {

   282

  symbol->var_name->accept(*this);

   283

  return NULL;

   284

}

   285

   286

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

   287

/* B.1.4.1   Directly Represented Variables */

   288

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

   289

// SYM_TOKEN(direct_variable_c)

   290

/* We do not yet handle this. Will we ever need to handle it, as the data type of the direct variable is

   291

 * directly obtainable from the syntax of the direct variable itself?

   292

 */

   293

   294

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

   295

/* B 1.4.2 - Multi-element variables */

   296

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

   297

/*  subscripted_variable '[' subscript_list ']' */

   298

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   299

/* NOTE: when passed a array_variable_c, which represents some IEC61131-3 code similar to X[42]

   300

 * we must return the data type of the value _stored_ in the array.

   301

 * If you want to get the data type of the array itself (i.e. just the X variable, without the [42])

   302

 * then this class must be called with the identifier_c 'X'.

   303

 */

   304

void *search_varfb_instance_type_c::visit(array_variable_c *symbol) {

   305

  /* determine the data type of the subscripted_variable... 

   306

   * This should be an array_specification_c

   307

   *    ARRAY [xx..yy] OF Stored_Data_Type

   308

   */

   309

  symbol->subscripted_variable->accept(*this);

   310

  symbol_c *basetype_decl = current_basetype_decl;

   311

  this->init(); /* set all current_*** pointers to NULL ! */

   312

   313

  /* Now we determine the 'Stored_Data_Type', i.e. the data type of the variable stored in the array. */

   314

  if (NULL != basetype_decl) {

   315

    basetype_decl->accept(*this);

   316

  }

   317

   318

  return NULL;

   319

}

   320

   321

   322

/*  record_variable '.' field_selector */

   323

/*  WARNING: input and/or output variables of function blocks

   324

 *           may be accessed as fields of a structured variable!

   325

 *           Code handling a structured_variable_c must take this into account!

   326

 *           (i.e. that a FB instance may be accessed as a structured variable)!

   327

 *

   328

 *  WARNING: Status bit (.X) and activation time (.T) of STEPS in SFC diagrams

   329

 *           may be accessed as fields of a structured variable!

   330

 *           Code handling a structured_variable_c must take this into account 

   331

 *           (i.e. that an SFC STEP may be accessed as a structured variable)!

   332

 */

   333

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   334

void *search_varfb_instance_type_c::visit(structured_variable_c *symbol) {

   335

  symbol->record_variable->accept(*this);

   336

  symbol_c *basetype_decl = current_basetype_decl;

   337

  this->init(); /* set all current_*** pointers to NULL ! */

   338

   339

  /* Now we search for the data type of the field... But only if we were able to determine the data type of the variable */

   340

  if (NULL != basetype_decl) {

   341

    current_field_selector = symbol->field_selector;

   342

    basetype_decl->accept(*this);

   343

    current_field_selector = NULL;

   344

  }

   345

   346

  return NULL;

   347

}

   348

   349

   350

   351

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

   352

/* B.1.5 - Program organization units */

   353

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

   354

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

   355

/* B 1.5.2 - Function Blocks */

   356

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

   357

   358

/*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   359

// SYM_REF4(function_block_declaration_c, fblock_name, var_declarations, fblock_body, unused)

   360

void *search_varfb_instance_type_c::visit(function_block_declaration_c *symbol) {

   361

  if (NULL == current_field_selector) return NULL; // the source code has a datatype consistency bug that will be caught later!!

   362

   363

  /* now search the function block declaration for the variable... */

   364

  /* If not found, these pointers will all be set to NULL!! */

   365

  search_var_instance_decl_c search_decl(symbol);

   366

  current_type_id       = search_decl.get_decl(current_field_selector);

   367

  current_basetype_decl = search_base_type_c::get_basetype_decl(current_type_id);

   368

  current_basetype_id   = search_base_type_c::get_basetype_id  (current_type_id);

   369

   370

  return NULL;

   371

}

   372

   373

   374

   375

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

   376

/* B.1.6  Sequential function chart elements */

   377

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

   378

/* INITIAL_STEP step_name ':' action_association_list END_STEP */

   379

// SYM_REF2(initial_step_c, step_name, action_association_list)

   380

/* NOTE: this method may be called from visit(structured_variable_c *symbol) method| */

   381

void *search_varfb_instance_type_c::visit(initial_step_c *symbol) {

   382

  if (NULL == current_field_selector) return NULL; // the source code has a datatype consistency bug that will be caught later!!

   383

   384

  identifier_c T("T");

   385

  identifier_c X("X");

   386

   387

  /* Hard code the datatypes of the implicit variables Stepname.X and Stepname.T */

   388

  if (compare_identifiers(&T, current_field_selector) == 0)   

   389

    current_type_id = &get_datatype_info_c::time_type_name;

   390

  if (compare_identifiers(&X, current_field_selector) == 0)   

   391

    current_type_id = &get_datatype_info_c::bool_type_name;

   392

   393

  current_basetype_decl = search_base_type_c::get_basetype_decl(current_type_id);

   394

  current_basetype_id   = search_base_type_c::get_basetype_id  (current_type_id);

   395

   396

  return NULL;

   397

}

   398

   399

   400

/* STEP step_name ':' action_association_list END_STEP */

   401

// SYM_REF2(step_c, step_name, action_association_list)

   402

/* NOTE: this method may be called from visit(structured_variable_c *symbol) method| */

   403

void *search_varfb_instance_type_c::visit(step_c *symbol) {

   404

  /* The code here should be identicial to the code in the visit(initial_step_c *) visitor! So we simply call the other visitor! */

   405

  initial_step_c initial_step(NULL, NULL);

   406

  return initial_step.accept(*this);

   407

}

   408

   409

   410

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

   411

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

   412

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

   413

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

   414

/* B 3.1 - Expressions */

   415

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

   416

/* SYM_REF1(deref_expression_c, exp)  --> an extension to the IEC 61131-3 standard - based on the IEC 61131-3 v3 standard. Returns address of the varible! */

   417

void *search_varfb_instance_type_c::visit(deref_expression_c  *symbol) {

   418

  symbol->exp->accept(*this);

   419

  symbol_c *basetype_decl = current_basetype_decl;

   420

  this->init(); /* set all current_*** pointers to NULL ! */

   421

   422

  /* Check whether the expression if a REF_TO datatype, and if so, set the new datatype to the datatype it references! */

   423

    /* Determine whether the datatype is a ref_spec_c, as this is the class used as the    */

   424

    /* canonical/base datatype of REF_TO types (see search_base_type_c ...)                */   

   425

  ref_spec_c * ref_spec = dynamic_cast<ref_spec_c *>(basetype_decl);

   426

  if (NULL != ref_spec) {

   427

    current_basetype_decl = search_base_type_c::get_basetype_decl(ref_spec->type_name);

   428

    current_basetype_id   = search_base_type_c::get_basetype_id  (ref_spec->type_name);

   429

  }

   430

   431

  return NULL;

   432

}

   433

   434

   435

/* SYM_REF1(deref_operator_c, exp)  --> an extension to the IEC 61131-3 standard - based on the IEC 61131-3 v3 standard. Returns address of the varible! */

   436

void *search_varfb_instance_type_c::visit(deref_operator_c  *symbol) {

   437

  symbol->exp->accept(*this);

   438

  symbol_c *basetype_decl = current_basetype_decl;

   439

  this->init(); /* set all current_*** pointers to NULL ! */

   440

   441

  /* Check whether the expression if a REF_TO datatype, and if so, set the new datatype to the datatype it references! */

   442

    /* Determine whether the datatype is a ref_spec_c, as this is the class used as the    */

   443

    /* canonical/base datatype of REF_TO types (see search_base_type_c ...)                */   

   444

  ref_spec_c * ref_spec = dynamic_cast<ref_spec_c *>(basetype_decl);

   445

  if (NULL != ref_spec) {

   446

    current_basetype_decl = search_base_type_c::get_basetype_decl(ref_spec->type_name);

   447

    current_basetype_id   = search_base_type_c::get_basetype_id  (ref_spec->type_name);

   448

  }

   449

   450

  return NULL;

   451

}