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)

     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 "function_param_iterator.hh"

    52

#include "spec_init_separator.hh"

    53

#include <strings.h>

    54

    55

    56

//#define DEBUG

    57

#ifdef DEBUG

    58

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

    59

#else

    60

#define TRACE(classname)

    61

#endif

    62

    63

    64

#define ERROR error_exit(__FILE__,__LINE__)

    65

/* function defined in main.cc */

    66

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

    67

    68

    69

    70

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

    71

  switch (current_operation) {

    72

    case iterate_op:

    73

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

    74

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

    75

    76

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

    77

      param_count += list->n;

    78

      break;

    79

    80

    case search_op:

    81

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

    82

        identifier_c *variable_name = dynamic_cast<identifier_c *>(list->elements[i]);

    83

        if (variable_name == NULL) ERROR;

    84

    85

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

    86

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

    87

          return (void *)variable_name;

    88

      }

    89

      break;

    90

  } /* switch */

    91

    92

  /* Not found! */

    93

  return NULL;

    94

}

    95

    96

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

    97

  switch (current_operation) {

    98

    case iterate_op:

    99

      param_count++;

   100

      if (next_param == param_count)

   101

        return var_name;

   102

      break;

   103

   104

    case search_op:

   105

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

   106

      if (variable_name == NULL) ERROR;

   107

   108

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

   109

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

   110

        return (void *)variable_name;

   111

      break;

   112

  } /* switch */

   113

   114

  /* Not found! */

   115

  return NULL;

   116

}

   117

   118

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

   119

  void *res;

   120

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

   121

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

   122

    if (res != NULL)

   123

        return res;

   124

  }

   125

  return NULL;

   126

}

   127

   128

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

   129

void function_param_iterator_c::reset(void) {

   130

  next_param = param_count = 0;

   131

  current_param_name = NULL;

   132

  current_param_type = current_param_default_value = NULL;

   133

}

   134

   135

   136

/* initialise the iterator object.

   137

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

   138

 *     - function_declaration_c

   139

 *     - function_block_declaration_c

   140

 *     - program_declaration_c

   141

 * that will be analysed...

   142

 */

   143

function_param_iterator_c::function_param_iterator_c(symbol_c *pou_decl) {

   144

  /* do some consistency checks... */

   145

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

   146

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

   147

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

   148

   149

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

   150

   151

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

   152

  this->f_decl = pou_decl;

   153

  reset();

   154

}

   155

   156

   157

   158

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

   159

 * the object references on parameter _before_ the first, so

   160

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

   161

 * reference the first parameter...

   162

 *

   163

 * Returns the parameter's name!

   164

 */

   165

identifier_c *function_param_iterator_c::next(void) {

   166

  void *res;

   167

  identifier_c *identifier;

   168

   169

  param_count = 0;

   170

  en_eno_param_implicit = false;

   171

  next_param++;

   172

  current_operation = function_param_iterator_c::iterate_op;

   173

  res = f_decl->accept(*this);

   174

  if (res == NULL) 

   175

    return NULL;

   176

   177

  symbol_c *sym = (symbol_c *)res;

   178

  identifier = dynamic_cast<identifier_c *>(sym);

   179

  if (identifier == NULL)

   180

    ERROR;

   181

  current_param_name = identifier;

   182

  return current_param_name;

   183

}

   184

   185

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

   186

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

   187

  if (NULL == param_name) ERROR;

   188

  search_param_name = dynamic_cast<identifier_c *>(param_name);

   189

  if (NULL == search_param_name) ERROR;

   190

  current_operation = function_param_iterator_c::search_op;

   191

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

   192

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

   193

  return res_param_name;

   194

}

   195

   196

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

   197

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

   198

 */

   199

symbol_c *function_param_iterator_c::default_value(void) {

   200

  return current_param_default_value;

   201

}

   202

   203

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

   204

symbol_c *function_param_iterator_c::param_type(void) {

   205

  return current_param_type;

   206

}

   207

   208

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

   209

bool function_param_iterator_c::is_en_eno_param_implicit(void) {

   210

  return en_eno_param_implicit;

   211

}

   212

   213

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

   214

 * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT

   215

 */

   216

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

   217

  return current_param_direction;

   218

}

   219

   220

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

   221

	en_eno_param_implicit = current_operation == function_param_iterator_c::iterate_op;

   222

	return NULL;

   223

}

   224

   225

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

   226

/* 1.4.3 - Declaration & Initialisation */

   227

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

   228

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

   229

  TRACE("input_declarations_c");

   230

  current_param_direction = direction_in;

   231

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

   232

}

   233

   234

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

   235

   236

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

   237

   238

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

   239

  TRACE("en_param_declaration_c");

   240

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

   241

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

   242

   * variable list we will be analysing, the current_param_XXXX

   243

   * variables will get overwritten when we visit the next

   244

   * var1_init_decl_c list!

   245

   */

   246

  symbol->method->accept(*this);

   247

   248

  current_param_default_value = symbol->value;

   249

  current_param_type = symbol->type;

   250

   251

  return handle_single_param(symbol->name);

   252

}

   253

   254

/* var1_list ':' array_spec_init */

   255

//SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   256

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

   257

  TRACE("array_var_init_decl_c");

   258

   259

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

   260

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

   261

   262

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

   263

}

   264

   265

/*  var1_list ':' initialized_structure */

   266

//SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   267

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

   268

  TRACE("structured_var_init_decl_c");

   269

   270

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

   271

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

   272

   273

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

   274

}

   275

   276

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

   277

  TRACE("output_declarations_c");

   278

  current_param_direction = direction_out;

   279

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

   280

}

   281

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

   282

  TRACE("eno_param_declaration_c");

   283

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

   284

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

   285

   * variable list we will be analysing, the current_param_XXXX

   286

   * variables will get overwritten when we visit the next

   287

   * var1_init_decl_c list!

   288

   */

   289

  symbol->method->accept(*this);

   290

   291

  current_param_default_value = NULL;

   292

  current_param_type = symbol->type;

   293

   294

  return handle_single_param(symbol->name);

   295

}

   296

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

   297

  TRACE("input_output_declarations_c");

   298

  current_param_direction = direction_inout;

   299

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

   300

}

   301

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

   302

   303

/*  var1_list ':' array_specification */

   304

//SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   305

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

   306

	TRACE("array_var_declaration_c");

   307

   308

	current_param_default_value = NULL;

   309

	current_param_type = symbol->array_specification;

   310

   311

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

   312

}

   313

   314

/*  var1_list ':' structure_type_name */

   315

//SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name)

   316

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

   317

  TRACE("structured_var_declaration_c");

   318

   319

  current_param_default_value = NULL;

   320

  current_param_type = symbol->structure_type_name;

   321

   322

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

   323

}

   324

   325

/* VAR [CONSTANT] var_init_decl_list END_VAR */

   326

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

   327

   328

/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */

   329

/* option -> may be NULL ! */

   330

// SYM_REF2(external_var_declarations_c, option, external_declaration_list)

   331

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

   332

  TRACE("external_var_declarations_c");

   333

  current_param_direction = direction_extref;

   334

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

   335

}

   336

   337

/* helper symbol for external_var_declarations */

   338

/*| external_declaration_list external_declaration';' */

   339

// SYM_LIST(external_declaration_list_c)

   340

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

   341

   342

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

   343

//SYM_REF2(external_declaration_c, global_var_name, specification)

   344

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

   345

  TRACE("external_declaration_c");

   346

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

   347

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

   348

   * variable list we will be analysing, the current_param_XXXX

   349

   * variables will get overwritten when we visit the next

   350

   * var1_init_decl_c list!

   351

   */

   352

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

   353

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

   354

   355

  return handle_single_param(symbol->global_var_name);

   356

}

   357

   358

   359

#if 0

   360

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

   361

/* option -> may be NULL ! */

   362

SYM_REF2(global_var_declarations_c, option, global_var_decl_list)

   363

   364

/* helper symbol for global_var_declarations */

   365

/*| global_var_decl_list global_var_decl ';' */

   366

SYM_LIST(global_var_decl_list_c)

   367

   368

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

   369

/* type_specification ->may be NULL ! */

   370

SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   371

   372

/*| global_var_name location */

   373

SYM_REF2(global_var_spec_c, global_var_name, location)

   374

   375

/*  AT direct_variable */

   376

SYM_REF2(location_c, direct_variable, unused)

   377

   378

/*| global_var_list ',' global_var_name */

   379

SYM_LIST(global_var_list_c)

   380

   381

/*  var1_list ':' single_byte_string_spec */

   382

SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec)

   383

   384

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

   385

/* integer ->may be NULL ! */

   386

/* single_byte_character_string ->may be NULL ! */

   387

SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string)

   388

   389

/*  var1_list ':' double_byte_string_spec */

   390

SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec)

   391

   392

/*  WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */

   393

/* integer ->may be NULL ! */

   394

/* double_byte_character_string ->may be NULL ! */

   395

SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string)

   396

   397

/*| VAR [RETAIN|NON_RETAIN] incompl_located_var_decl_list END_VAR */

   398

/* option ->may be NULL ! */

   399

SYM_REF2(incompl_located_var_declarations_c, option, incompl_located_var_decl_list)

   400

   401

/* helper symbol for incompl_located_var_declarations */

   402

/*| incompl_located_var_decl_list incompl_located_var_decl ';' */

   403

SYM_LIST(incompl_located_var_decl_list_c)

   404

   405

/*  variable_name incompl_location ':' var_spec */

   406

SYM_REF4(incompl_located_var_decl_c, variable_name, incompl_location, var_spec, unused)

   407

   408

/*  AT incompl_location_token */

   409

SYM_TOKEN(incompl_location_c)

   410

#endif

   411

   412

   413

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

   414

  TRACE("var1_init_decl_c");

   415

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

   416

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

   417

   * variable list we will be analysing, the current_param_XXXX

   418

   * variables will get overwritten when we visit the next

   419

   * var1_init_decl_c list!

   420

   */

   421

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

   422

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

   423

   424

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

   425

}

   426

   427

   428

   429

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

   430

  TRACE("var1_list_c");

   431

  return handle_param_list(symbol);

   432

}

   433

   434

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

   435

   436

   437

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

   438

/* B 1.5.1 - Functions */

   439

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

   440

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

   441

/* intermediate helper symbol for function_declaration */

   442

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

   443

void *function_param_iterator_c::visit(function_var_decls_c *symbol) {TRACE("function_var_decls_c"); /* ignore */ return NULL;}

   444

   445

   446

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

   447

/* B 1.5.2 - Function Blocks */

   448

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

   449

/*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   450

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

   451

   452

/* intermediate helper symbol for function_declaration */

   453

/*  { io_var_declarations | other_var_declarations }   */

   454

/*

   455

 * NOTE: we re-use the var_declarations_list_c

   456

 */

   457

   458

/*  VAR_TEMP temp_var_decl_list END_VAR */

   459

void *function_param_iterator_c::visit(temp_var_decls_c *symbol) {TRACE("temp_var_decls_c"); /* ignore */ return NULL;}

   460

void *function_param_iterator_c::visit(temp_var_decls_list_c *symbol) {TRACE("temp_var_decls_list_c"); /* ignore */ return NULL;}

   461

   462

/*  VAR NON_RETAIN var_init_decl_list END_VAR */

   463

void *function_param_iterator_c::visit(non_retentive_var_decls_c *symbol) {TRACE("non_retentive_var_decls_c"); /* ignore */ return NULL;}

   464

   465

   466

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

   467

/* B 1.5.3 - Programs */

   468

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

   469

/*  PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */

   470

// SYM_REF4(program_declaration_c, program_type_name, var_declarations, function_block_body, unused)

   471

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

   472

   473

/* intermediate helper symbol for program_declaration_c */

   474

/*  { io_var_declarations | other_var_declarations }   */

   475

/*

   476

 * NOTE: we re-use the var_declarations_list_c

   477

 */

   478

   479

   480

   481

   482

   483