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

 *

     6

 *  This program is free software: you can redistribute it and/or modify

     7

 *  it under the terms of the GNU General Public License as published by

     8

 *  the Free Software Foundation, either version 3 of the License, or

     9

 *  (at your option) any later version.

    10

 *

    11

 *  This program is distributed in the hope that it will be useful,

    12

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    13

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    14

 *  GNU General Public License for more details.

    15

 *

    16

 *  You should have received a copy of the GNU General Public License

    17

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    18

 *

    19

 *

    20

 * This code is made available on the understanding that it will not be

    21

 * used in safety-critical situations without a full and competent review.

    22

 */

    23

    24

/*

    25

 * An IEC 61131-3 compiler.

    26

 *

    27

 * Based on the

    28

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    29

 *

    30

 */

    31

    32

    33

/*

    34

 * Function parameter iterator.

    35

 * Iterate through the in/out parameters of a function declaration.

    36

 * Function blocks are also suported.

    37

 *

    38

 * This is part of the 4th stage that generates

    39

 * a c++ source program equivalent to the IL and ST

    40

 * code.

    41

 */

    42

    43

/* Given a function_declaration_c, iterate through each

    44

 * function in/out/inout parameter, returning the name

    45

 * of each parameter...function_param_iterator_c

    46

 */

    47

    48

    49

    50

#include "function_param_iterator.hh"

    51

#include "spec_init_separator.hh"

    52

#include <strings.h>

    53

    54

    55

//#define DEBUG

    56

#ifdef DEBUG

    57

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

    58

#else

    59

#define TRACE(classname)

    60

#endif

    61

    62

    63

#define ERROR error_exit(__FILE__,__LINE__)

    64

/* function defined in main.cc */

    65

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

    66

    67

    68

    69

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

    70

  switch (current_operation) {

    71

    case iterate_op:

    72

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

    73

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

    74

    75

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

    76

      param_count += list->n;

    77

      break;

    78

    79

    case search_op:

    80

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

    81

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

    82

        if (variable_name == NULL) ERROR;

    83

    84

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

    85

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

    86

          return (void *)variable_name;

    87

      }

    88

      break;

    89

  } /* switch */

    90

    91

  /* Not found! */

    92

  return NULL;

    93

}

    94

    95

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

    96

  switch (current_operation) {

    97

    case iterate_op:

    98

      param_count++;

    99

      if (next_param == param_count)

   100

        return var_name;

   101

      break;

   102

   103

    case search_op:

   104

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

   105

      if (variable_name == NULL) ERROR;

   106

   107

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

   108

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

   109

        return (void *)variable_name;

   110

      break;

   111

  } /* switch */

   112

   113

  /* Not found! */

   114

  return NULL;

   115

}

   116

   117

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

   118

  void *res;

   119

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

   120

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

   121

    if (res != NULL)

   122

        return res;

   123

  }

   124

  return NULL;

   125

}

   126

   127

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

   128

void function_param_iterator_c::reset(void) {

   129

  next_param = param_count = 0;

   130

  current_param_name = NULL;

   131

  current_param_type = current_param_default_value = NULL;

   132

}

   133

   134

   135

/* initialise the iterator object.

   136

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

   137

 *     - function_declaration_c

   138

 *     - function_block_declaration_c

   139

 *     - program_declaration_c

   140

 * that will be analysed...

   141

 */

   142

function_param_iterator_c::function_param_iterator_c(symbol_c *pou_decl) {

   143

  /* do some consistency checks... */

   144

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

   145

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

   146

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

   147

   148

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

   149

   150

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

   151

  this->f_decl = pou_decl;

   152

  reset();

   153

}

   154

   155

   156

   157

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

   158

 * the object references on parameter _before_ the first, so

   159

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

   160

 * reference the first parameter...

   161

 *

   162

 * Returns the parameter's name!

   163

 */

   164

identifier_c *function_param_iterator_c::next(void) {

   165

  void *res;

   166

  identifier_c *identifier;

   167

   168

  param_count = 0;

   169

  en_eno_param_implicit = false;

   170

  next_param++;

   171

  current_operation = function_param_iterator_c::iterate_op;

   172

  res = f_decl->accept(*this);

   173

  if (res == NULL) 

   174

    return NULL;

   175

   176

  symbol_c *sym = (symbol_c *)res;

   177

  identifier = dynamic_cast<identifier_c *>(sym);

   178

  if (identifier == NULL)

   179

    ERROR;

   180

  current_param_name = identifier;

   181

  return current_param_name;

   182

}

   183

   184

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

   185

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

   186

  if (NULL == param_name) ERROR;

   187

  search_param_name = dynamic_cast<identifier_c *>(param_name);

   188

  if (NULL == search_param_name) ERROR;

   189

  current_operation = function_param_iterator_c::search_op;

   190

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

   191

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

   192

  return res_param_name;

   193

}

   194

   195

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

   196

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

   197

 */

   198

symbol_c *function_param_iterator_c::default_value(void) {

   199

  return current_param_default_value;

   200

}

   201

   202

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

   203

symbol_c *function_param_iterator_c::param_type(void) {

   204

  return current_param_type;

   205

}

   206

   207

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

   208

bool function_param_iterator_c::is_en_eno_param_implicit(void) {

   209

  return en_eno_param_implicit;

   210

}

   211

   212

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

   213

 * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT

   214

 */

   215

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

   216

  return current_param_direction;

   217

}

   218

   219

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

   220

	en_eno_param_implicit = current_operation == function_param_iterator_c::iterate_op;

   221

	return NULL;

   222

}

   223

   224

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

   225

/* 1.4.3 - Declaration & Initialisation */

   226

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

   227

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

   228

  TRACE("input_declarations_c");

   229

  current_param_direction = direction_in;

   230

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

   231

}

   232

   233

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

   234

   235

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

   236

   237

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

   238

  TRACE("en_param_declaration_c");

   239

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

   240

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

   241

   * variable list we will be analysing, the current_param_XXXX

   242

   * variables will get overwritten when we visit the next

   243

   * var1_init_decl_c list!

   244

   */

   245

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

   246

   247

  current_param_default_value = symbol->value;

   248

  current_param_type = symbol->type;

   249

   250

  return handle_single_param(symbol->name);

   251

}

   252

   253

/* var1_list ':' array_spec_init */

   254

//SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   255

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

   256

  TRACE("array_var_init_decl_c");

   257

   258

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

   259

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

   260

   261

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

   262

}

   263

   264

/*  var1_list ':' initialized_structure */

   265

//SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   266

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

   267

  TRACE("structured_var_init_decl_c");

   268

   269

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

   270

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

   271

   272

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

   273

}

   274

   275

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

   276

  TRACE("output_declarations_c");

   277

  current_param_direction = direction_out;

   278

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

   279

}

   280

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

   281

  TRACE("eno_param_declaration_c");

   282

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

   283

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

   284

   * variable list we will be analysing, the current_param_XXXX

   285

   * variables will get overwritten when we visit the next

   286

   * var1_init_decl_c list!

   287

   */

   288

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

   289

   290

  current_param_default_value = NULL;

   291

  current_param_type = symbol->type;

   292

   293

  return handle_single_param(symbol->name);

   294

}

   295

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

   296

  TRACE("input_output_declarations_c");

   297

  current_param_direction = direction_inout;

   298

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

   299

}

   300

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

   301

   302

/*  var1_list ':' array_specification */

   303

//SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   304

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

   305

	TRACE("array_var_declaration_c");

   306

   307

	current_param_default_value = NULL;

   308

	current_param_type = symbol->array_specification;

   309

   310

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

   311

}

   312

   313

/*  var1_list ':' structure_type_name */

   314

//SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name)

   315

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

   316

  TRACE("structured_var_declaration_c");

   317

   318

  current_param_default_value = NULL;

   319

  current_param_type = symbol->structure_type_name;

   320

   321

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

   322

}

   323

   324

/* VAR [CONSTANT] var_init_decl_list END_VAR */

   325

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

   326

   327

/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */

   328

/* option -> may be NULL ! */

   329

// SYM_REF2(external_var_declarations_c, option, external_declaration_list)

   330

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

   331

  TRACE("external_var_declarations_c");

   332

  current_param_direction = direction_extref;

   333

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

   334

}

   335

   336

/* helper symbol for external_var_declarations */

   337

/*| external_declaration_list external_declaration';' */

   338

// SYM_LIST(external_declaration_list_c)

   339

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

   340

   341

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

   342

//SYM_REF2(external_declaration_c, global_var_name, specification)

   343

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

   344

  TRACE("external_declaration_c");

   345

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

   346

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

   347

   * variable list we will be analysing, the current_param_XXXX

   348

   * variables will get overwritten when we visit the next

   349

   * var1_init_decl_c list!

   350

   */

   351

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

   352

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

   353

   354

  return handle_single_param(symbol->global_var_name);

   355

}

   356

   357

   358

#if 0

   359

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

   360

/* option -> may be NULL ! */

   361

SYM_REF2(global_var_declarations_c, option, global_var_decl_list)

   362

   363

/* helper symbol for global_var_declarations */

   364

/*| global_var_decl_list global_var_decl ';' */

   365

SYM_LIST(global_var_decl_list_c)

   366

   367

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

   368

/* type_specification ->may be NULL ! */

   369

SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   370

   371

/*| global_var_name location */

   372

SYM_REF2(global_var_spec_c, global_var_name, location)

   373

   374

/*  AT direct_variable */

   375

SYM_REF2(location_c, direct_variable, unused)

   376

   377

/*| global_var_list ',' global_var_name */

   378

SYM_LIST(global_var_list_c)

   379

   380

/*  var1_list ':' single_byte_string_spec */

   381

SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec)

   382

   383

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

   384

/* integer ->may be NULL ! */

   385

/* single_byte_character_string ->may be NULL ! */

   386

SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string)

   387

   388

/*  var1_list ':' double_byte_string_spec */

   389

SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec)

   390

   391

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

   392

/* integer ->may be NULL ! */

   393

/* double_byte_character_string ->may be NULL ! */

   394

SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string)

   395

   396

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

   397

/* option ->may be NULL ! */

   398

SYM_REF2(incompl_located_var_declarations_c, option, incompl_located_var_decl_list)

   399

   400

/* helper symbol for incompl_located_var_declarations */

   401

/*| incompl_located_var_decl_list incompl_located_var_decl ';' */

   402

SYM_LIST(incompl_located_var_decl_list_c)

   403

   404

/*  variable_name incompl_location ':' var_spec */

   405

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

   406

   407

/*  AT incompl_location_token */

   408

SYM_TOKEN(incompl_location_c)

   409

#endif

   410

   411

   412

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

   413

  TRACE("var1_init_decl_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 = spec_init_sperator_c::get_init(symbol->spec_init);

   421

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

   422

   423

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

   424

}

   425

   426

   427

   428

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

   429

  TRACE("var1_list_c");

   430

  return handle_param_list(symbol);

   431

}

   432

   433

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

   434

   435

   436

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

   437

/* B 1.5.1 - Functions */

   438

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

   439

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

   440

/* intermediate helper symbol for function_declaration */

   441

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

   442

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

   443

   444

   445

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

   446

/* B 1.5.2 - Function Blocks */

   447

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

   448

/*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   449

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

   450

   451

/* intermediate helper symbol for function_declaration */

   452

/*  { io_var_declarations | other_var_declarations }   */

   453

/*

   454

 * NOTE: we re-use the var_declarations_list_c

   455

 */

   456

   457

/*  VAR_TEMP temp_var_decl_list END_VAR */

   458

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

   459

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

   460

   461

/*  VAR NON_RETAIN var_init_decl_list END_VAR */

   462

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

   463

   464

   465

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

   466

/* B 1.5.3 - Programs */

   467

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

   468

/*  PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */

   469

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

   470

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

   471

   472

/* intermediate helper symbol for program_declaration_c */

   473

/*  { io_var_declarations | other_var_declarations }   */

   474

/*

   475

 * NOTE: we re-use the var_declarations_list_c

   476

 */

   477

   478

   479

   480

   481

   482