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

    52

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

    53

#include <string.h>

    54

#include <strings.h>

    57

    58

//#define DEBUG

    59

#ifdef DEBUG

    60

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

    61

#else

    62

#define TRACE(classname)

    63

#endif

    64

    65

    66

#define ERROR error_exit(__FILE__,__LINE__)

    67

/* function defined in main.cc */

    68

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

    69

    70

    71

   127

/* compare the name of two __extensible__ function parameters.

   128

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

   129

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

   130

 *

   131

 * Will return:

   132

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

   133

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

   134

 */

   135

/*

   136

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

   137

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

   138

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

   139

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

   140

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

   141

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

   142

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

   143

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

   144

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

   145

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

   146

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

   147

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

   148

 */

   149

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

   150

  int res;

   151

  char *endptr;

   152

  int len;

   153

   154

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

   155

   156

  len = strlen(s1);

   157

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

   158

   159

  s1 = &s2[len];

   160

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

   161

   162

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

   163

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

   164

   165

  return res;

   166

}

   167

   168

   169

   170

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

   171

  switch (current_operation) {

   172

    case iterate_op:

   173

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

   174

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

   175

   176

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

   177

      param_count += list->n;

   178

      break;

   179

   180

    case search_op:

   181

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

   182

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

   183

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

   184

        if (extensible_parameter != NULL) {

   185

          sym = extensible_parameter->var_name;

   186

          current_param_is_extensible = true;

   188

        }

   189

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

   190

        if (variable_name == NULL) ERROR;

   191

   192

        if (!current_param_is_extensible)

   193

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

   194

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

   195

            return (void *)variable_name;

   196

   197

        if (current_param_is_extensible) {

   198

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

   199

          if (current_extensible_param_index >= 0)

   200

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

   201

            return (void *)variable_name;

   202

        }  

   203

      }

   204

      break;

   205

  } /* switch */

   206

   207

  /* Not found! */

   208

  return NULL;

   209

}

   210

   211

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

   212

  switch (current_operation) {

   213

    case iterate_op:

   214

      param_count++;

   215

      if (next_param == param_count)

   216

        return var_name;

   217

      break;

   218

   219

    case search_op:

   220

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

   221

      if (extensible_parameter != NULL) {

   222

        var_name = extensible_parameter->var_name;

   223

        current_param_is_extensible = true;

   225

      }

   226

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

   227

      if (variable_name == NULL) ERROR;

   228

   229

      if (!current_param_is_extensible)

   230

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

   231

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

   232

          return (void *)variable_name;

   233

   234

      if (current_param_is_extensible) {

   235

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

   236

        if (current_extensible_param_index >= 0)

   237

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

   238

          return (void *)variable_name;

   239

      }  

   240

      break;

   241

  } /* switch */

   242

   243

  /* Not found! */

   244

  return NULL;

   245

}

   246

   247

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

   248

  void *res;

   249

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

   250

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

   251

    if (res != NULL)

   252

        return res;

   253

  }

   254

  return NULL;

   255

}

   256

   257

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

   258

void function_param_iterator_c::reset(void) {

   259

  next_param = param_count = 0;

   260

  _first_extensible_param_index = -1;

   261

  current_param_is_extensible = false;

   262

  current_param_name = NULL;

   263

  current_param_type = NULL;

   264

  current_param_default_value = NULL;

   265

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

   266

}

   267

   268

   269

/* initialise the iterator object.

   270

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

   271

 *     - function_declaration_c

   272

 *     - function_block_declaration_c

   273

 *     - program_declaration_c

   274

 * that will be analysed...

   275

 */

   276

function_param_iterator_c::function_param_iterator_c(symbol_c *pou_decl) {

   277

  /* do some consistency checks... */

   278

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

   279

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

   280

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

   281

   282

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

   283

    ERROR;

   284

   285

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

   286

  this->f_decl = pou_decl;

   287

  reset();

   288

}

   289

   290

   291

   292

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

   293

 * the object references on parameter _before_ the first, so

   294

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

   295

 * reference the first parameter...

   296

 *

   297

 * Returns the parameter's name!

   298

 */

   299

identifier_c *function_param_iterator_c::next(void) {

   300

  void *res;

   301

  identifier_c *identifier;

   302

   303

  if (current_param_is_extensible) {

   304

    current_extensible_param_index++;

   305

    return current_param_name;

   306

  }

   307

   308

  last_returned_parameter = NULL; 

   309

  param_count = 0;

   310

  en_eno_param_implicit = false;

   311

  next_param++;

   312

  current_operation = function_param_iterator_c::iterate_op;

   313

  res = f_decl->accept(*this);

   314

  if (res == NULL) 

   315

    return NULL;

   316

   317

  symbol_c *sym = (symbol_c *)res;

   318

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

   319

  if (extensible_parameter != NULL) {

   320

    sym = extensible_parameter->var_name;

   321

    current_param_is_extensible = true;

   323

    current_extensible_param_index = _first_extensible_param_index;

   324

  }

   325

  identifier = dynamic_cast<identifier_c *>(sym);

   326

  if (identifier == NULL)

   327

    ERROR;

   328

  current_param_name = identifier;

   329

  last_returned_parameter = current_param_name; 

   330

  return current_param_name;

   331

}

   332

   333

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

   334

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

   335

  if (NULL == param_name) ERROR;

   336

  search_param_name = dynamic_cast<identifier_c *>(param_name);

   337

  if (NULL == search_param_name) ERROR;

   338

  en_eno_param_implicit = false;

   339

  current_param_is_extensible = false;

   340

  current_operation = function_param_iterator_c::search_op;

   341

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

   342

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

   343

  last_returned_parameter = res_param_name; 

   344

  return res_param_name;

   345

}

   346

   347

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

   348

  identifier_c   param_name_id(param_name);

   349

  return search(&param_name_id);

   350

}

   351

   352

   353

   354

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

   355

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

   356

 */

   357

symbol_c *function_param_iterator_c::default_value(void) {

   358

  if (NULL == last_returned_parameter) 

   359

    return NULL;

   360

  return current_param_default_value;

   361

}

   362

   363

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

   364

symbol_c *function_param_iterator_c::param_type(void) {

   365

  if (NULL == last_returned_parameter) 

   366

    return NULL;

   367

  return current_param_type;

   368

}

   369

   370

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

   371

bool function_param_iterator_c::is_en_eno_param_implicit(void) {

   372

  if (NULL == last_returned_parameter) 

   373

    ERROR;

   374

  return en_eno_param_implicit;

   375

}

   376

   377

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

   378

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

   379

bool function_param_iterator_c::is_extensible_param(void) {

   380

  if (NULL == last_returned_parameter) 

   381

    ERROR;

   382

  return current_param_is_extensible;

   383

}

   384

   385

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

   386

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

   387

int function_param_iterator_c::extensible_param_index(void) {

   388

  if (NULL == last_returned_parameter) 

   389

    ERROR;

   390

  return (current_param_is_extensible? current_extensible_param_index : -1);

   391

}

   392

   393

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

   394

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

   395

int function_param_iterator_c::first_extensible_param_index(void) {

   396

  return _first_extensible_param_index;

   397

}

   398

   399

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

   400

 * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT

   401

 */

   402

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

   403

  if (NULL == last_returned_parameter) 

   404

    ERROR;

   405

  return current_param_direction;

   406

}

   407

   408

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

   409

	en_eno_param_implicit = true;

   410

	return NULL;

   411

}

   412

   413

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

   414

/* 1.4.3 - Declaration & Initialisation */

   415

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

   416

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

   417

  TRACE("input_declarations_c");

   418

  current_param_direction = direction_in;

   419

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

   420

}

   421

   422

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

   423

   424

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

   425

   426

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

   427

  TRACE("en_param_declaration_c");

   428

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

   429

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

   430

   * variable list we will be analysing, the current_param_XXXX

   431

   * variables will get overwritten when we visit the next

   432

   * var1_init_decl_c list!

   433

   */

   434

  current_param_default_value = symbol->value;

   435

  current_param_type = symbol->type;

   436

   437

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

   438

   439

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

   440

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

   441

   442

  return res;

   443

}

   444

   445

/* var1_list ':' array_spec_init */

   446

//SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   447

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

   448

  TRACE("array_var_init_decl_c");

   449

   450

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

   451

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

   452

   453

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

   454

}

   455

   456

/*  var1_list ':' initialized_structure */

   457

//SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   458

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

   459

  TRACE("structured_var_init_decl_c");

   460

   461

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

   462

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

   463

   464

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

   465

}

   466

   467

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

   468

  TRACE("output_declarations_c");

   469

  current_param_direction = direction_out;

   470

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

   471

}

   472

   473

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

   474

  TRACE("eno_param_declaration_c");

   475

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

   476

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

   477

   * variable list we will be analysing, the current_param_XXXX

   478

   * variables will get overwritten when we visit the next

   479

   * var1_init_decl_c list!

   480

   */

   481

  current_param_default_value = NULL;

   482

  current_param_type = symbol->type;

   483

   484

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

   485

   486

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

   487

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

   488

   489

  return res;

   490

}

   491

   492

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

   493

  TRACE("input_output_declarations_c");

   494

  current_param_direction = direction_inout;

   495

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

   496

}

   497

   498

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

   499