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 = current_param_default_value = NULL;

   210

}

   211

   212

   213

/* initialise the iterator object.

   214

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

   215

 *     - function_declaration_c

   216

 *     - function_block_declaration_c

   217

 *     - program_declaration_c

   218

 * that will be analysed...

   219

 */

   220

function_param_iterator_c::function_param_iterator_c(symbol_c *pou_decl) {

   221

  /* do some consistency checks... */

   222

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

   223

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

   224

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

   225

   226

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

   227

   228

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

   229

  this->f_decl = pou_decl;

   230

  reset();

   231

}

   232

   233

   234

   235

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

   236

 * the object references on parameter _before_ the first, so

   237

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

   238

 * reference the first parameter...

   239

 *

   240

 * Returns the parameter's name!

   241

 */

   242

identifier_c *function_param_iterator_c::next(void) {

   243

  void *res;

   244

  identifier_c *identifier;

   245

   246

  if (current_param_is_extensible) {

   247

    current_extensible_param_index++;

   248

    return current_param_name;

   249

  }

   250

   251

  param_count = 0;

   252

  en_eno_param_implicit = false;

   253

  next_param++;

   254

  current_operation = function_param_iterator_c::iterate_op;

   255

  res = f_decl->accept(*this);

   256

  if (res == NULL) 

   257

    return NULL;

   258

   259

  symbol_c *sym = (symbol_c *)res;

   260

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

   261

  if (extensible_parameter != NULL) {

   262

    sym = extensible_parameter->var_name;

   263

    current_param_is_extensible = true;

   264

    _first_extensible_param_index = extract_integer(extensible_parameter->first_index);

   265

    current_extensible_param_index = _first_extensible_param_index;

   266

  }

   267

  identifier = dynamic_cast<identifier_c *>(sym);

   268

  if (identifier == NULL)

   269

    ERROR;

   270

  current_param_name = identifier;

   271

  return current_param_name;

   272

}

   273

   274

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

   275

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

   276

  if (NULL == param_name) ERROR;

   277

  search_param_name = dynamic_cast<identifier_c *>(param_name);

   278

  if (NULL == search_param_name) ERROR;

   279

  en_eno_param_implicit = false;

   280

  current_param_is_extensible = false;

   281

  current_operation = function_param_iterator_c::search_op;

   282

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

   283

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

   284

  return res_param_name;

   285

}

   286

   287

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

   288

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

   289

 */

   290

symbol_c *function_param_iterator_c::default_value(void) {

   291

  return current_param_default_value;

   292

}

   293

   294

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

   295

symbol_c *function_param_iterator_c::param_type(void) {

   296

  return current_param_type;

   297

}

   298

   299

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

   300

bool function_param_iterator_c::is_en_eno_param_implicit(void) {

   301

  return en_eno_param_implicit;

   302

}

   303

   304

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

   305

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

   306

bool function_param_iterator_c::is_extensible_param(void) {

   307

  return current_param_is_extensible;

   308

}

   309

   310

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

   311

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

   312

int function_param_iterator_c::extensible_param_index(void) {

   313

  return (current_param_is_extensible? current_extensible_param_index : -1);

   314

}

   315

   316

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

   317

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

   318

int function_param_iterator_c::first_extensible_param_index(void) {

   319

  return _first_extensible_param_index;

   320

}

   321

   322

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

   323

 * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT

   324

 */

   325

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

   326

  return current_param_direction;

   327

}

   328

   329

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

   330

	en_eno_param_implicit = true;

   331

	return NULL;

   332

}

   333

   334

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

   335

/* 1.4.3 - Declaration & Initialisation */

   336

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

   337

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

   338

  TRACE("input_declarations_c");

   339

  current_param_direction = direction_in;

   340

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

   341

}

   342

   343

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

   344

   345

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

   346

   347

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

   348

  TRACE("en_param_declaration_c");

   349

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

   350

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

   351

   * variable list we will be analysing, the current_param_XXXX

   352

   * variables will get overwritten when we visit the next

   353

   * var1_init_decl_c list!

   354

   */

   355

  current_param_default_value = symbol->value;

   356

  current_param_type = symbol->type;

   357

   358

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

   359

   360

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

   361

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

   362

   363

  return res;

   364

}

   365

   366

/* var1_list ':' array_spec_init */

   367

//SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   368

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

   369

  TRACE("array_var_init_decl_c");

   370

   371

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

   372

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

   373

   374

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

   375

}

   376

   377

/*  var1_list ':' initialized_structure */

   378

//SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   379

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

   380

  TRACE("structured_var_init_decl_c");

   381

   382

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

   383

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

   384

   385

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

   386

}

   387

   388

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

   389

  TRACE("output_declarations_c");

   390

  current_param_direction = direction_out;

   391

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

   392

}

   393

   394

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

   395

  TRACE("eno_param_declaration_c");

   396

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

   397

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

   398

   * variable list we will be analysing, the current_param_XXXX

   399

   * variables will get overwritten when we visit the next

   400

   * var1_init_decl_c list!

   401

   */

   402

  current_param_default_value = NULL;

   403

  current_param_type = symbol->type;

   404

   405

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

   406

   407

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

   408

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

   409

   410

  return res;

   411

}

   412

   413

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

   414

  TRACE("input_output_declarations_c");

   415

  current_param_direction = direction_inout;

   416

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

   417

}

   418

   419

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

   420

   421

/*  var1_list ':' array_specification */

   422

//SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   423

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

   424

	TRACE("array_var_declaration_c");

   425

   426

	current_param_default_value = NULL;

   427

	current_param_type = symbol->array_specification;

   428

   429

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

   430

}

   431

   432

/*  var1_list ':' structure_type_name */

   433

//SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name)

   434

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

   435

  TRACE("structured_var_declaration_c");

   436

   437

  current_param_default_value = NULL;

   438

  current_param_type = symbol->structure_type_name;

   439

   440

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

   441

}

   442

   443

/* VAR [CONSTANT] var_init_decl_list END_VAR */

   444

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

   445

   446

/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */

   447

/* option -> may be NULL ! */

   448

// SYM_REF2(external_var_declarations_c, option, external_declaration_list)

   449

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

   450

  TRACE("external_var_declarations_c");

   451

  current_param_direction = direction_extref;

   452

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

   453

}

   454

   455

/* helper symbol for external_var_declarations */

   456

/*| external_declaration_list external_declaration';' */

   457

// SYM_LIST(external_declaration_list_c)

   458

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

   459

   460

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

   461

//SYM_REF2(external_declaration_c, global_var_name, specification)

   462

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

   463

  TRACE("external_declaration_c");

   464

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

   465

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

   466

   * variable list we will be analysing, the current_param_XXXX

   467

   * variables will get overwritten when we visit the next

   468

   * var1_init_decl_c list!

   469

   */

   470

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

   471

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

   472

   473

  return handle_single_param(symbol->global_var_name);

   474

}

   475

   476

   477

#if 0

   478

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

   479

/* option -> may be NULL ! */

   480

SYM_REF2(global_var_declarations_c, option, global_var_decl_list)

   481

   482

/* helper symbol for global_var_declarations */

   483

/*| global_var_decl_list global_var_decl ';' */

   484

SYM_LIST(global_var_decl_list_c)

   485

   486

/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */

   487

/* type_specification ->may be NULL ! */

   488

SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   489

   490

/*| global_var_name location */

   491

SYM_REF2(global_var_spec_c, global_var_name, location)

   492

   493

/*  AT direct_variable */

   494

SYM_REF2(location_c, direct_variable, unused)

   495

   496

/*| global_var_list ',' global_var_name */

   497

SYM_LIST(global_var_list_c)

   498

   499

/*  var1_list ':' single_byte_string_spec */

   500

SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec)

   501

   502

/*  STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */

   503

/* integer ->may be NULL ! */

   504

/* single_byte_character_string ->may be NULL ! */

   505

SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string)

   506