1

/*

     2

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

     3

 *

     4

 *  Copyright (C) 2003-2011  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

    34

/*

    35

 * Function parameter iterator.

    36

 * Iterate through the in/out parameters of a function declaration.

    37

 * Function blocks are also suported.

    38

 *

    39

 * This is part of the 4th stage that generates

    40

 * a c++ source program equivalent to the IL and ST

    41

 * code.

    42

 */

    43

    44

/* Given a function_declaration_c, iterate through each

    45

 * function in/out/inout parameter, returning the name

    46

 * of each parameter...function_param_iterator_c

    47

 */

    48

    49

    50

#include "function_param_iterator.hh"  /* no longer required, aready included by absyntax_utils.hh */

    51

#include "spec_init_separator.hh"  /* no longer required, aready included by absyntax_utils.hh */

    52

#include <stdlib.h>  /* required for strtol() */

    53

#include <string.h>

    54

#include <strings.h>

    55

#include <limits> // required for std::numeric_limits< XXX >::max()

    56

#include <errno.h> // required for errno

    57

#include "../main.hh" // required for ERROR() and ERROR_MSG() macros.

    58

    59

//#define DEBUG

    60

#ifdef DEBUG

    61

#define TRACE(classname) printf("\n____%s____\n",classname);

    62

#else

    63

#define TRACE(classname)

    64

#endif

    65

    66

    67

    68

    69

    70

/* NOTE: The following function is not really needed, as we could get the value that constant_folding_c determined for this

    71

 *       integer. Remember that currently constant_folding_c runs before this class is ever used/called!

    72

 *       However, I (Mario) do not currently feel it would be a good idea to restrict the use of this

    73

 *       abstract syntax utility to only after the constant_folding_c has had a chance to fill in the constant value

    74

 *       of this symbol. 

    75

 *       For this reason only, I have opted to let this abstract syntax utility have its own private copy of the

    76

 *       extract_integer() function.

    77

 *       Another aspect that makes this OK is that this function will only be used to extract the integer value of the

    78

 *       index for the first extensible paramater (examples follow shortly). Since this is an extension to IEC 61131-3 

    79

 *       that we created to allow us to handle extensible functions with very little hard coding, it is OK if we

    80

 *       impose extra/different limits on how an integer may be legally be formated in this case. This will also 

    81

 *       only show up in code that describes the interface to the standard function of IEC 61131-3, which the user

    82

 *       will not ever get to see. We write that IEC 61131-3 code ourselves!

    83

 *

    84

 *      Example of source code we will be parsing and analysing:

    85

 *

    86

 *      FUNCTION ADD : REAL VAR_INPUT IN 1 .. : REAL; END_VAR RETURN; END_FUNCTION

    87

 *                                      ^^^

    88

 *

    89

 *      FUNCTION MUX : REAL VAR_INPUT K : USINT; IN 0 .. : REAL; END_VAR RETURN; END_FUNCTION

    90

 *                                                 ^^^

    91

 *

    92

 *      Basically, currently this will only be either a '0' or a '1' !!

    93

 */

    94

    95

/* NOTE: it must ignore underscores! */

    96

static int extract_first_index_value(symbol_c *sym) {

    97

  std::string str = "";

    98

  integer_c *integer;

    99

  long int ret;

   100

   101

  if ((integer = dynamic_cast<integer_c *>(sym)) == NULL) ERROR;

   102

  for(unsigned int i = 0; i < strlen(integer->value); i++)

   103

    if (integer->value[i] != '_')  str += integer->value[i];

   104

   105

  errno = 0; // since strtoXX() may legally return 0, we must set errno to 0 to detect errors correctly!

   106

  ret = strtol(str.c_str(), NULL, 10);

   107

  if (errno != 0) ERROR;

   108

  if (ret < 0) ERROR; // the following code assumes that the first index will never be negative!

   109

  if (ret > std::numeric_limits< int >::max()) ERROR; // output of this function is only an int!!

   110

   111

  return ret;

   112

}

   113

   114

   115

   116

   117

   118

   119

   120

   121

   122

   123

/* compare the name of two __extensible__ function parameters.

   124

 * The usual use case is to have one of the parameters as used

   125

 * in the function declaration, and another as used in a formal function call.

   126

 *

   127

 * Will return:

   128

 *         < 0 : if two parameters are not compatible, or one is invalid

   129

 *        >= 0 : if both parameters ..........

   130

 */

   131

/*

   132

 *   ("in", "i0")      -> returns error (<0)

   133

 *   ("in1", "in")     -> returns error (<0)

   134

 *   ("in", "in")      -> returns error (<0)

   135

 *   ("in", "inw")     -> returns error (<0)

   136

 *   ("in", "in10.4")  -> returns error (<0)

   137

 *   ("in", "in10e")   -> returns error (<0)

   138

 *   ("in", "")        -> returns error (<0)

   139

 *   ("", "in10e")     -> returns error (<0)

   140

 *   ("in", "in0")     -> returns 0

   141

 *   ("in", "in9")     -> returns 9

   142

 *   ("in", "in42")    -> returns 42

   143

 *   ("in", "in-42")   -> returns -42 (error!)

   144

 */

   145

int function_param_iterator_c::cmp_extparam_names(const char* s1, const char* s2) {

   146

  int res;

   147

  char *endptr;

   148

  int len;

   149

   150

  if ((s1 == NULL) || (s2 == NULL) || (*s1 == '\0') || (*s2 == '\0')) return -1;

   151

   152

  len = strlen(s1);

   153

  if (strncasecmp(s1, s2, len)) return -2;

   154

   155

  s1 = &s2[len];

   156

  if (*s1 == '\0') return -3;

   157

   158

  res = strtol(s1, &endptr, 10);

   159

  if (*endptr != '\0') return -4;

   160

   161

  return res;

   162

}

   163

   164

   165

   166

void* function_param_iterator_c::handle_param_list(list_c *list) {

   167

  switch (current_operation) {

   168

    case iterate_op:

   169

      if (next_param <= param_count + list->n)

   170

        return list->elements[next_param - param_count - 1];

   171

   172

      /* the desired param is not on this list... */

   173

      param_count += list->n;

   174

      break;

   175

   176

    case search_op:

   177

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

   178

        symbol_c *sym = list->elements[i];

   179

        extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(sym);

   180

        if (extensible_parameter != NULL) {

   181

          sym = extensible_parameter->var_name;

   182

          current_param_is_extensible = true;

   183

          _first_extensible_param_index = extract_first_index_value(extensible_parameter->first_index);

   184

        }

   185

        identifier_c *variable_name = dynamic_cast<identifier_c *>(sym);

   186

        if (variable_name == NULL) ERROR;

   187

   188

        if (!current_param_is_extensible)

   189

          if (strcasecmp(search_param_name->value, variable_name->value) == 0)

   190

            /* FOUND! This is the same parameter!! */

   191

            return (void *)variable_name;

   192

   193

        if (current_param_is_extensible) {

   194

          current_extensible_param_index = cmp_extparam_names(variable_name->value, search_param_name->value);

   195

          if (current_extensible_param_index >= 0)

   196

            /* FOUND! This is a compatible extensible parameter!! */

   197

            return (void *)variable_name;

   198

        }  

   199

      }

   200

      break;

   201

  } /* switch */

   202

   203

  /* Not found! */

   204

  return NULL;

   205

}

   206

   207

void* function_param_iterator_c::handle_single_param(symbol_c *var_name) {

   208

  switch (current_operation) {

   209

    case iterate_op:

   210

      param_count++;

   211

      if (next_param == param_count)

   212

        return var_name;

   213

      break;

   214

   215

    case search_op:

   216

      extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(var_name);

   217

      if (extensible_parameter != NULL) {

   218

        var_name = extensible_parameter->var_name;

   219

        current_param_is_extensible = true;

   220

        _first_extensible_param_index = extract_first_index_value(extensible_parameter->first_index);

   221

      }

   222

      identifier_c *variable_name = dynamic_cast<identifier_c *>(var_name);

   223

      if (variable_name == NULL) ERROR;

   224

   225

      if (!current_param_is_extensible)

   226

        if (strcasecmp(search_param_name->value, variable_name->value) == 0)

   227

          /* FOUND! This is the same parameter!! */

   228

          return (void *)variable_name;

   229

   230

      if (current_param_is_extensible) {

   231

        current_extensible_param_index = cmp_extparam_names(variable_name->value, search_param_name->value);

   232

        if (current_extensible_param_index >= 0)

   233

          /* FOUND! This is a compatible extensible parameter!! */

   234

          return (void *)variable_name;

   235

      }  

   236

      break;

   237

  } /* switch */

   238

   239

  /* Not found! */

   240

  return NULL;

   241

}

   242

   243

void* function_param_iterator_c::iterate_list(list_c *list) {

   244

  void *res;

   245

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

   246

    res = list->elements[i]->accept(*this);

   247

    if (res != NULL)

   248

        return res;

   249

  }

   250

  return NULL;

   251

}

   252

   253

/* start off at the first parameter once again... */

   254

void function_param_iterator_c::reset(void) {

   255

  next_param = param_count = 0;

   256

  _first_extensible_param_index = -1;

   257

  current_param_is_extensible = false;

   258

  current_param_name = NULL;

   259

  current_param_type = NULL;

   260

  current_param_default_value = NULL;

   261

  last_returned_parameter = NULL; /* the last parameter returned by search() or next() */

   262

}

   263

   264

   265

/* initialise the iterator object.

   266

 * We must be given a reference to one of the following

   267

 *     - function_declaration_c

   268

 *     - function_block_declaration_c

   269

 *     - program_declaration_c

   270

 * that will be analysed...

   271

 */

   272

function_param_iterator_c::function_param_iterator_c(symbol_c *pou_decl) {

   273

  /* do some consistency checks... */

   274

  function_declaration_c       * f_decl = dynamic_cast<function_declaration_c       *>(pou_decl);

   275

  function_block_declaration_c *fb_decl = dynamic_cast<function_block_declaration_c *>(pou_decl);

   276

  program_declaration_c        * p_decl = dynamic_cast<program_declaration_c        *>(pou_decl);

   277

   278

  if ((NULL == f_decl) && (NULL == fb_decl) && (NULL == p_decl)) 

   279

    ERROR;

   280

   281

  /* OK. Now initialise this object... */

   282

  this->f_decl = pou_decl;

   283

  reset();

   284

}

   285

   286

   287

   288

/* Skip to the next parameter. After object creation,

   289

 * the object references on parameter _before_ the first, so

   290

 * this function must be called once to get the object to

   291

 * reference the first parameter...

   292

 *

   293

 * Returns the parameter's name!

   294

 */

   295

identifier_c *function_param_iterator_c::next(void) {

   296

  void *res;

   297

  identifier_c *identifier;

   298

   299

  if (current_param_is_extensible) {

   300

    current_extensible_param_index++;

   301

    return current_param_name;

   302

  }

   303

   304

  last_returned_parameter = NULL; 

   305

  param_count = 0;

   306

  en_eno_param_implicit = false;

   307

  next_param++;

   308

  current_operation = function_param_iterator_c::iterate_op;

   309

  res = f_decl->accept(*this);

   310

  if (res == NULL) 

   311

    return NULL;

   312

   313

  symbol_c *sym = (symbol_c *)res;

   314

  extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(sym);

   315

  if (extensible_parameter != NULL) {

   316

    sym = extensible_parameter->var_name;

   317

    current_param_is_extensible = true;

   318

    _first_extensible_param_index = extract_first_index_value(extensible_parameter->first_index);

   319

    current_extensible_param_index = _first_extensible_param_index;

   320

  }

   321

  identifier = dynamic_cast<identifier_c *>(sym);

   322

  if (identifier == NULL)

   323

    ERROR;

   324

  current_param_name = identifier;

   325

  last_returned_parameter = current_param_name; 

   326

  return current_param_name;

   327

}

   328

   329

/* Search for the value passed to the parameter named <param_name>...  */

   330

identifier_c *function_param_iterator_c::search(symbol_c *param_name) {

   331

  if (NULL == param_name) ERROR;

   332

  search_param_name = dynamic_cast<identifier_c *>(param_name);

   333

  if (NULL == search_param_name) ERROR;

   334

  en_eno_param_implicit = false;

   335

  current_param_is_extensible = false;

   336

  current_operation = function_param_iterator_c::search_op;

   337

  void *res = f_decl->accept(*this);

   338

  identifier_c *res_param_name = dynamic_cast<identifier_c *>((symbol_c *)res);

   339

  last_returned_parameter = res_param_name; 

   340

  return res_param_name;

   341

}

   342

   343

identifier_c *function_param_iterator_c::search(const char *param_name) {

   344

  identifier_c   param_name_id(param_name);

   345

  return search(&param_name_id);

   346

}

   347

   348

   349

   350

/* Returns the currently referenced parameter's default value,

   351

 * or NULL if none is specified in the function declrataion itself.

   352

 */

   353

symbol_c *function_param_iterator_c::default_value(void) {

   354

  if (NULL == last_returned_parameter) 

   355

    return NULL;

   356

  return current_param_default_value;

   357

}

   358

   359

/* Returns the currently referenced parameter's type name. */

   360

symbol_c *function_param_iterator_c::param_type(void) {

   361

  if (NULL == last_returned_parameter) 

   362

    return NULL;

   363

  return current_param_type;

   364

}

   365

   366

/* Returns if currently referenced parameter is an implicit defined EN/ENO parameter. */

   367

bool function_param_iterator_c::is_en_eno_param_implicit(void) {

   368

  if (NULL == last_returned_parameter) 

   369

    ERROR;

   370

  return en_eno_param_implicit;

   371

}

   372

   373

/* Returns if currently referenced parameter is an extensible parameter. */

   374

/* extensible paramters only occur in some standard functions, e.g. AND(word#34, word#44, word#65); */

   375

bool function_param_iterator_c::is_extensible_param(void) {

   376

  if (NULL == last_returned_parameter) 

   377

    ERROR;

   378

  return current_param_is_extensible;

   379

}

   380

   381

/* Returns the index of the current extensible parameter. */             

   382

/* If the current parameter is not an extensible paramter, returns -1 */

   383

int function_param_iterator_c::extensible_param_index(void) {

   384

  if (NULL == last_returned_parameter) 

   385

    ERROR;

   386

  return (current_param_is_extensible? current_extensible_param_index : -1);

   387

}

   388

   389

/* Returns the index of the first extensible parameter, or -1 if no extensible parameter found. */             

   390

/* WARNING: Will only return the correct value _after_ an extensible parameter has been found! */

   391

int function_param_iterator_c::first_extensible_param_index(void) {

   392

  return _first_extensible_param_index;

   393

}

   394

   395

/* Returns the currently referenced parameter's data passing direction.

   396

 * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT

   397

 */

   398

function_param_iterator_c::param_direction_t function_param_iterator_c::param_direction(void) {

   399

  if (NULL == last_returned_parameter) 

   400

    ERROR;

   401

  return current_param_direction;

   402

}

   403

   404

void *function_param_iterator_c::visit(implicit_definition_c *symbol) {

   405

	en_eno_param_implicit = true;

   406

	return NULL;

   407

}

   408

   409

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

   410

/* 1.4.3 - Declaration & Initialisation */

   411

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

   412

void *function_param_iterator_c::visit(input_declarations_c *symbol) {

   413

  TRACE("input_declarations_c");

   414

  current_param_direction = direction_in;

   415

  return symbol->input_declaration_list->accept(*this);

   416

}

   417

   418

void *function_param_iterator_c::visit(input_declaration_list_c *symbol) {TRACE("input_declaration_list_c"); return iterate_list(symbol);}

   419

   420

void *function_param_iterator_c::visit(edge_declaration_c *symbol) {TRACE("edge_declaration_c"); return symbol->var1_list->accept(*this);}

   421

   422

void *function_param_iterator_c::visit(en_param_declaration_c *symbol) {

   423

  TRACE("en_param_declaration_c");

   424

  /* It is OK to store these values in the current_param_XXX

   425

   * variables, because if the desired parameter is not in the

   426

   * variable list we will be analysing, the current_param_XXXX

   427

   * variables will get overwritten when we visit the next

   428

   * var1_init_decl_c list!

   429

   */

   430

  current_param_default_value = symbol->value;

   431

  current_param_type = symbol->type;

   432

   433

  void *res = handle_single_param(symbol->name);

   434

   435

    /* If we have found the parameter we will be returning, we set the en_eno_param_implicit to TRUE if implicitly defined */

   436

  if (res != NULL) symbol->method->accept(*this);

   437

   438

  return res;

   439

}

   440

   441

/* var1_list ':' array_spec_init */

   442

//SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   443

void *function_param_iterator_c::visit(array_var_init_decl_c *symbol) {

   444

  TRACE("array_var_init_decl_c");

   445

   446

  current_param_default_value = spec_init_sperator_c::get_init(symbol->array_spec_init);

   447

  current_param_type = spec_init_sperator_c::get_spec(symbol->array_spec_init);

   448

   449

  return symbol->var1_list->accept(*this);

   450

}

   451

   452

/*  var1_list ':' initialized_structure */

   453

//SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   454

void *function_param_iterator_c::visit(structured_var_init_decl_c *symbol) {

   455

  TRACE("structured_var_init_decl_c");

   456

   457

  current_param_default_value = spec_init_sperator_c::get_init(symbol->initialized_structure);

   458

  current_param_type = spec_init_sperator_c::get_spec(symbol->initialized_structure);

   459

   460

  return symbol->var1_list->accept(*this);

   461

}

   462

   463

void *function_param_iterator_c::visit(output_declarations_c *symbol) {

   464

  TRACE("output_declarations_c");

   465

  current_param_direction = direction_out;

   466

  return symbol->var_init_decl_list->accept(*this);

   467

}

   468

   469

void *function_param_iterator_c::visit(eno_param_declaration_c *symbol) {

   470

  TRACE("eno_param_declaration_c");

   471

  /* It is OK to store these values in the current_param_XXX

   472

   * variables, because if the desired parameter is not in the

   473

   * variable list we will be analysing, the current_param_XXXX

   474

   * variables will get overwritten when we visit the next

   475

   * var1_init_decl_c list!

   476

   */

   477

  current_param_default_value = NULL;

   478

  current_param_type = symbol->type;

   479

   480

  void *res = handle_single_param(symbol->name);

   481

   482

    /* If we have found the parameter we will be returning, we set the en_eno_param_implicit to TRUE if implicitly defined */

   483

  if (res != NULL) symbol->method->accept(*this);

   484

   485

  return res;

   486

}

   487

   488

void *function_param_iterator_c::visit(input_output_declarations_c *symbol) {

   489

  TRACE("input_output_declarations_c");

   490

  current_param_direction = direction_inout;

   491

  return symbol->var_declaration_list->accept(*this);

   492

}

   493

   494

void *function_param_iterator_c::visit(var_declaration_list_c *symbol) {TRACE("var_declaration_list_c"); return iterate_list(symbol);}

   495

   496

/*  var1_list ':' array_specification */

   497

//SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   498

void *function_param_iterator_c::visit(array_var_declaration_c *symbol) {

   499

	TRACE("array_var_declaration_c");