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

    51

#include "absyntax_utils.hh"  /* required for extract_integer() */

    52

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

    53

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

    54

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

    55

#include <string.h>

    56

#include <strings.h>

    57

    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

#define ERROR error_exit(__FILE__,__LINE__)

    68

/* function defined in main.cc */

    69

extern void error_exit(const char *file_name, int line_no);

    70

    71

    72

    73

/* compare the name of two __extensible__ function parameters.

    74

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

    75

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

    76

 *

    77

 * Will return:

    78

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

    79

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

    80

 */

    81

/*

    82

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

    83

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

    84

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

    85

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

    86

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

    87

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

    88

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

    89

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

    90

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

    91

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

    92

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

    93

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

    94

 */

    95

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

    96

  int res;

    97

  char *endptr;

    98

  int len;

    99

   100

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

   101

   102

  len = strlen(s1);

   103

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

   104

   105

  s1 = &s2[len];

   106

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

   107

   108

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

   109

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

   110

   111

  return res;

   112

}

   113

   114

   115

   116

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

   117

  switch (current_operation) {

   118

    case iterate_op:

   119

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

   120

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

   121

   122

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

   123

      param_count += list->n;

   124

      break;

   125

   126

    case search_op:

   127

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

   128

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

   129

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

   130

        if (extensible_parameter != NULL) {

   131

          sym = extensible_parameter->var_name;

   132

          current_param_is_extensible = true;

   133

          _first_extensible_param_index = extract_integer(extensible_parameter->first_index);

   134

        }

   135

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

   136

        if (variable_name == NULL) ERROR;

   137

   138

        if (!current_param_is_extensible)

   139

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

   140

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

   141

            return (void *)variable_name;

   142

   143

        if (current_param_is_extensible) {

   144

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

   145

          if (current_extensible_param_index >= 0)

   146

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

   147

            return (void *)variable_name;

   148

        }  

   149

      }

   150

      break;

   151

  } /* switch */

   152

   153

  /* Not found! */

   154

  return NULL;

   155

}

   156

   157

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

   158

  switch (current_operation) {

   159

    case iterate_op:

   160

      param_count++;

   161

      if (next_param == param_count)

   162

        return var_name;

   163

      break;

   164

   165

    case search_op:

   166

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

   167

      if (extensible_parameter != NULL) {

   168

        var_name = extensible_parameter->var_name;

   169

        current_param_is_extensible = true;

   170

        _first_extensible_param_index = extract_integer(extensible_parameter->first_index);

   171

      }

   172

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

   173

      if (variable_name == NULL) ERROR;

   174

   175

      if (!current_param_is_extensible)

   176

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

   177

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

   178

          return (void *)variable_name;

   179

   180

      if (current_param_is_extensible) {

   181

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

   182

        if (current_extensible_param_index >= 0)

   183

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

   184

          return (void *)variable_name;

   185

      }  

   186

      break;

   187

  } /* switch */

   188

   189

  /* Not found! */

   190

  return NULL;

   191

}

   192

   193

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

   194

  void *res;

   195

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

   196

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

   197

    if (res != NULL)

   198

        return res;

   199

  }

   200

  return NULL;

   201

}

   202

   203

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

   204

void function_param_iterator_c::reset(void) {

   205

  next_param = param_count = 0;

   206

  _first_extensible_param_index = -1;

   207

  current_param_is_extensible = false;

   208

  current_param_name = NULL;

   209

  current_param_type = NULL;

   210

  current_param_default_value = NULL;

   211

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

   212

}

   213

   214

   215

/* initialise the iterator object.

   216

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

   217

 *     - function_declaration_c

   218

 *     - function_block_declaration_c

   219

 *     - program_declaration_c

   220

 * that will be analysed...

   221

 */

   222

function_param_iterator_c::function_param_iterator_c(symbol_c *pou_decl) {

   223

  /* do some consistency checks... */

   224

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

   225

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

   226

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

   227

   230

   231

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

   232

  this->f_decl = pou_decl;

   233

  reset();

   234

}

   235

   236

   237

   238

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

   239

 * the object references on parameter _before_ the first, so

   240

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

   241

 * reference the first parameter...

   242

 *

   243

 * Returns the parameter's name!

   244

 */

   245

identifier_c *function_param_iterator_c::next(void) {

   246

  void *res;

   247

  identifier_c *identifier;

   248

   249

  if (current_param_is_extensible) {

   250

    current_extensible_param_index++;

   251

    return current_param_name;

   252

  }

   253

   254

  last_returned_parameter = NULL; 

   255

  param_count = 0;

   256

  en_eno_param_implicit = false;

   257

  next_param++;

   258

  current_operation = function_param_iterator_c::iterate_op;

   259

  res = f_decl->accept(*this);

   260

  if (res == NULL) 

   261

    return NULL;

   262

   263

  symbol_c *sym = (symbol_c *)res;

   264

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

   265

  if (extensible_parameter != NULL) {

   266

    sym = extensible_parameter->var_name;

   267

    current_param_is_extensible = true;

   268

    _first_extensible_param_index = extract_integer(extensible_parameter->first_index);

   269

    current_extensible_param_index = _first_extensible_param_index;

   270

  }

   271

  identifier = dynamic_cast<identifier_c *>(sym);

   272

  if (identifier == NULL)

   273

    ERROR;

   274

  current_param_name = identifier;

   275

  last_returned_parameter = current_param_name; 

   276

  return current_param_name;

   277

}

   278

   279

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

   280

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

   281

  if (NULL == param_name) ERROR;

   282

  search_param_name = dynamic_cast<identifier_c *>(param_name);

   283

  if (NULL == search_param_name) ERROR;

   284

  en_eno_param_implicit = false;

   285

  current_param_is_extensible = false;

   286

  current_operation = function_param_iterator_c::search_op;

   287

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

   288

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

   289

  last_returned_parameter = res_param_name; 

   290

  return res_param_name;

   291

}

   292

   293

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

   294

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

   295

 */

   296

symbol_c *function_param_iterator_c::default_value(void) {

   297

  if (NULL == last_returned_parameter) 

   298

    return NULL;

   299

  return current_param_default_value;

   300

}

   301

   302

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

   303

symbol_c *function_param_iterator_c::param_type(void) {

   304

  if (NULL == last_returned_parameter) 

   305

    return NULL;

   306

  return current_param_type;

   307

}

   308

   309

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

   310

bool function_param_iterator_c::is_en_eno_param_implicit(void) {

   311

  if (NULL == last_returned_parameter) 

   312

    ERROR;

   313

  return en_eno_param_implicit;

   314

}

   315

   316

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

   317

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

   318

bool function_param_iterator_c::is_extensible_param(void) {

   319

  if (NULL == last_returned_parameter) 

   320

    ERROR;

   321

  return current_param_is_extensible;

   322

}

   323

   324

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

   325

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

   326

int function_param_iterator_c::extensible_param_index(void) {

   327

  if (NULL == last_returned_parameter) 

   328

    ERROR;

   329

  return (current_param_is_extensible? current_extensible_param_index : -1);

   330

}

   331

   332

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

   333

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

   334

int function_param_iterator_c::first_extensible_param_index(void) {

   335

  return _first_extensible_param_index;

   336

}

   337

   338

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

   339

 * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT

   340

 */

   341

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

   342

  if (NULL == last_returned_parameter) 

   343

    ERROR;

   344

  return current_param_direction;

   345

}

   346

   347

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

   348

	en_eno_param_implicit = true;

   349

	return NULL;

   350

}

   351

   352

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

   353

/* 1.4.3 - Declaration & Initialisation */

   354

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

   355

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

   356

  TRACE("input_declarations_c");

   357

  current_param_direction = direction_in;

   358

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

   359

}

   360

   361

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

   362

   363

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

   364

   365

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

   366

  TRACE("en_param_declaration_c");

   367

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

   368

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

   369

   * variable list we will be analysing, the current_param_XXXX

   370

   * variables will get overwritten when we visit the next

   371

   * var1_init_decl_c list!

   372

   */

   373

  current_param_default_value = symbol->value;

   374

  current_param_type = symbol->type;

   375

   376

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

   377

   378

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

   379

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

   380

   381

  return res;

   382

}

   383

   384

/* var1_list ':' array_spec_init */

   385

//SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   386

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

   387

  TRACE("array_var_init_decl_c");

   388

   389

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

   390

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

   391

   392

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

   393

}

   394

   395

/*  var1_list ':' initialized_structure */

   396

//SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   397

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

   398

  TRACE("structured_var_init_decl_c");

   399

   400

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

   401

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

   402

   403

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

   404

}

   405

   406

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

   407

  TRACE("output_declarations_c");

   408

  current_param_direction = direction_out;

   409

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

   410

}

   411

   412

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

   413

  TRACE("eno_param_declaration_c");

   414

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

   415

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

   416

   * variable list we will be analysing, the current_param_XXXX

   417

   * variables will get overwritten when we visit the next

   418

   * var1_init_decl_c list!

   419

   */

   420

  current_param_default_value = NULL;

   421

  current_param_type = symbol->type;

   422

   423

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

   424

   425

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

   426

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

   427

   428

  return res;

   429

}

   430

   431

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

   432

  TRACE("input_output_declarations_c");

   433

  current_param_direction = direction_inout;

   434

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

   435

}

   436

   437

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

   438

   439

/*  var1_list ':' array_specification */

   440

//SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   441

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

   442

	TRACE("array_var_declaration_c");

   443

   444

	current_param_default_value = NULL;

   445

	current_param_type = symbol->array_specification;

   446

   447

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

   448

}

   449

   450

/*  var1_list ':' structure_type_name */

   451

//SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name)

   452

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

   453

  TRACE("structured_var_declaration_c");

   454

   455

  current_param_default_value = NULL;

   456

  current_param_type = symbol->structure_type_name;

   457

   458

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

   459

}

   460

   461

/* VAR [CONSTANT] var_init_decl_list END_VAR */

   462

void *function_param_iterator_c::visit(var_declarations_c *symbol) {TRACE("var_declarations_c"); return NULL;}

   463

   464

/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */

   465

/* option -> may be NULL ! */

   466

// SYM_REF2(external_var_declarations_c, option, external_declaration_list)

   467

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

   468

  TRACE("external_var_declarations_c");

   469

  current_param_direction = direction_extref;

   470

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

   471

}

   472

   473

/* helper symbol for external_var_declarations */

   474

/*| external_declaration_list external_declaration';' */

   475

// SYM_LIST(external_declaration_list_c)

   476

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

   477

   478

/*  global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */

   479

//SYM_REF2(external_declaration_c, global_var_name, specification)

   480

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

   481

  TRACE("external_declaration_c");

   482

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

   483

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

   484

   * variable list we will be analysing, the current_param_XXXX

   485

   * variables will get overwritten when we visit the next

   486

   * var1_init_decl_c list!

   487

   */

   488

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

   489

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

   490

   491

  return handle_single_param(symbol->global_var_name);

   492

}

   493

   494

   495

#if 0

   496

/*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */

   497

/* option -> may be NULL ! */

   498

SYM_REF2(global_var_declarations_c, option, global_var_decl_list)

   499

   500

/* helper symbol for global_var_declarations */

   501

/*| global_var_decl_list global_var_decl ';' */

   502

SYM_LIST(global_var_decl_list_c)

   503