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_int64_value(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_int64_value(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

   228

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

   229

    ERROR;

   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_int64_value(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

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

   294

  identifier_c   param_name_id(param_name);

   295

  return search(&param_name_id);

   296

}

   297

   298

   299

   300

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

   301

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

   302

 */

   303

symbol_c *function_param_iterator_c::default_value(void) {

   304

  if (NULL == last_returned_parameter) 

   305

    return NULL;

   306

  return current_param_default_value;

   307

}

   308

   309

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

   310

symbol_c *function_param_iterator_c::param_type(void) {

   311

  if (NULL == last_returned_parameter) 

   312

    return NULL;

   313

  return current_param_type;

   314

}

   315

   316

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

   317

bool function_param_iterator_c::is_en_eno_param_implicit(void) {

   318

  if (NULL == last_returned_parameter) 

   319

    ERROR;

   320

  return en_eno_param_implicit;

   321

}

   322

   323

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

   324

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

   325

bool function_param_iterator_c::is_extensible_param(void) {

   326

  if (NULL == last_returned_parameter) 

   327

    ERROR;

   328

  return current_param_is_extensible;

   329

}

   330

   331

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

   332

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

   333

int function_param_iterator_c::extensible_param_index(void) {

   334

  if (NULL == last_returned_parameter) 

   335

    ERROR;

   336

  return (current_param_is_extensible? current_extensible_param_index : -1);

   337

}

   338

   339

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

   340

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

   341

int function_param_iterator_c::first_extensible_param_index(void) {

   342

  return _first_extensible_param_index;

   343

}

   344

   345

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

   346

 * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT

   347

 */

   348

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

   349

  if (NULL == last_returned_parameter) 

   350

    ERROR;

   351

  return current_param_direction;

   352

}

   353

   354

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

   355

	en_eno_param_implicit = true;

   356

	return NULL;

   357

}

   358

   359

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

   360

/* 1.4.3 - Declaration & Initialisation */

   361

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

   362

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

   363

  TRACE("input_declarations_c");

   364

  current_param_direction = direction_in;

   365

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

   366

}

   367

   368

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

   369

   370

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

   371

   372

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

   373

  TRACE("en_param_declaration_c");

   374

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

   375

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

   376

   * variable list we will be analysing, the current_param_XXXX

   377

   * variables will get overwritten when we visit the next

   378

   * var1_init_decl_c list!

   379

   */

   380

  current_param_default_value = symbol->value;

   381

  current_param_type = symbol->type;

   382

   383

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

   384

   385

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

   386

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

   387

   388

  return res;

   389

}

   390

   391

/* var1_list ':' array_spec_init */

   392

//SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   393

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

   394

  TRACE("array_var_init_decl_c");

   395

   396

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

   397

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

   398

   399

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

   400

}

   401

   402

/*  var1_list ':' initialized_structure */

   403

//SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   404

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

   405

  TRACE("structured_var_init_decl_c");

   406

   407

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

   408

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

   409

   410

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

   411

}

   412

   413

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

   414

  TRACE("output_declarations_c");

   415

  current_param_direction = direction_out;

   416

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

   417

}

   418

   419

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

   420

  TRACE("eno_param_declaration_c");

   421

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

   422

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

   423

   * variable list we will be analysing, the current_param_XXXX

   424

   * variables will get overwritten when we visit the next

   425

   * var1_init_decl_c list!

   426

   */

   427

  current_param_default_value = NULL;

   428

  current_param_type = symbol->type;

   429

   430

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

   431

   432

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

   433

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

   434

   435

  return res;

   436

}

   437

   438

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

   439

  TRACE("input_output_declarations_c");

   440

  current_param_direction = direction_inout;

   441

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

   442

}

   443

   444

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

   445

   446

/*  var1_list ':' array_specification */

   447

//SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   448

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

   449

	TRACE("array_var_declaration_c");

   450

   451

	current_param_default_value = NULL;

   452

	current_param_type = symbol->array_specification;

   453

   454

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

   455

}

   456

   457

/*  var1_list ':' structure_type_name */

   458

//SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name)

   459

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

   460

  TRACE("structured_var_declaration_c");

   461

   462

  current_param_default_value = NULL;

   463

  current_param_type = symbol->structure_type_name;

   464

   465

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

   466

}

   467

   468

/* VAR [CONSTANT] var_init_decl_list END_VAR */

   469

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

   470

   471

/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */

   472

/* option -> may be NULL ! */

   473

// SYM_REF2(external_var_declarations_c, option, external_declaration_list)

   474

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

   475

  TRACE("external_var_declarations_c");

   476

  current_param_direction = direction_extref;

   477

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

   478

}

   479

   480

/* helper symbol for external_var_declarations */

   481

/*| external_declaration_list external_declaration';' */

   482

// SYM_LIST(external_declaration_list_c)

   483

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

   484

   485

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

   486

//SYM_REF2(external_declaration_c, global_var_name, specification)

   487

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

   488

  TRACE("external_declaration_c");

   489

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

   490

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

   491

   * variable list we will be analysing, the current_param_XXXX

   492

   * variables will get overwritten when we visit the next

   493

   * var1_init_decl_c list!

   494

   */

   495

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

   496

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

   497

   498

  return handle_single_param(symbol->global_var_name);

   499

}

   500

   501

   502

#if 0