1

/*

     2

 * (c) 2003 Mario de Sousa

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

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

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

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

    14

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

    15

 */

    16

    17

/*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

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

    22

 *

    23

 */

    24

    25

    26

/*

    27

 * Function parameter iterator.

    28

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

    29

 * Function blocks are also suported.

    30

 *

    31

 * This is part of the 4th stage that generates

    32

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

    33

 * code.

    34

 */

    35

    36

/* Given a function_declaration_c, iterate through each

    37

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

    38

 * of each parameter...function_param_iterator_c

    39

 */

    40

    41

    42

    43

#include "function_param_iterator.hh"

    44

#include "spec_init_separator.hh"

    45

#include <strings.h>

    46

    47

    48

//#define DEBUG

    49

#ifdef DEBUG

    50

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

    51

#else

    52

#define TRACE(classname)

    53

#endif

    54

    55

    56

#define ERROR error_exit(__FILE__,__LINE__)

    57

/* function defined in main.cc */

    58

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

    59

    60

    61

    62

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

    63

  switch (current_operation) {

    64

    case iterate_op:

    65

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

    66

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

    67

    68

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

    69

      param_count += list->n;

    70

      break;

    71

    72

    case search_op:

    73

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

    74

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

    75

        if (variable_name == NULL) ERROR;

    76

    77

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

    78

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

    79

          return (void *)variable_name;

    80

      }

    81

      break;

    82

  } /* switch */

    83

    84

  /* Not found! */

    85

  return NULL;

    86

}

    87

    88

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

    89

  switch (current_operation) {

    90

    case iterate_op:

    91

      param_count++;

    92

      if (next_param == param_count)

    93

        return var_name;

    94

      break;

    95

    96

    case search_op:

    97

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

    98

      if (variable_name == NULL) ERROR;

    99

   100

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

   101

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

   102

        return (void *)variable_name;

   103

      break;

   104

  } /* switch */

   105

   106

  /* Not found! */

   107

  return NULL;

   108

}

   109

   110

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

   111

  void *res;

   112

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

   113

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

   114

    if (res != NULL)

   115

        return res;

   116

  }

   117

  return NULL;

   118

}

   119

   120

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

   121

void function_param_iterator_c::reset(void) {

   122

  next_param = param_count = 0;

   123

  current_param_name = NULL;

   124

  current_param_type = current_param_default_value = NULL;

   125

}

   126

   127

   128

/* initialise the iterator object.

   129

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

   130

 *     - function_declaration_c

   131

 *     - function_block_declaration_c

   132

 *     - program_declaration_c

   133

 * that will be analysed...

   134

 */

   135

function_param_iterator_c::function_param_iterator_c(symbol_c *pou_decl) {

   136

  /* do some consistency checks... */

   137

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

   138

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

   139

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

   140

   141

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

   142

   143

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

   144

  this->f_decl = pou_decl;

   145

  reset();

   146

}

   147

   148

   149

   150

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

   151

 * the object references on parameter _before_ the first, so

   152

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

   153

 * reference the first parameter...

   154

 *

   155

 * Returns the parameter's name!

   156

 */

   157

identifier_c *function_param_iterator_c::next(void) {

   158

  void *res;

   159

  identifier_c *identifier;

   160

   161

  param_count = 0;

   163

  next_param++;

   164

  current_operation = function_param_iterator_c::iterate_op;

   165

  res = f_decl->accept(*this);

   166

  if (res == NULL) 

   167

    return NULL;

   168

   169

  symbol_c *sym = (symbol_c *)res;

   170

  identifier = dynamic_cast<identifier_c *>(sym);

   171

  if (identifier == NULL)

   172

    ERROR;

   173

  current_param_name = identifier;

   174

  return current_param_name;

   175

}

   176

   177

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

   178

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

   179

  if (NULL == param_name) ERROR;

   180

  search_param_name = dynamic_cast<identifier_c *>(param_name);

   181

  if (NULL == search_param_name) ERROR;

   182

  current_operation = function_param_iterator_c::search_op;

   183

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

   184

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

   185

  return res_param_name;

   186

}

   187

   188

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

   189

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

   190

 */

   191

symbol_c *function_param_iterator_c::default_value(void) {

   192

  return current_param_default_value;

   193

}

   194

   195

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

   196

symbol_c *function_param_iterator_c::param_type(void) {

   197

  return current_param_type;

   198

}

   199

   205

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

   206

 * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT

   207

 */

   208

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

   209

  return current_param_direction;

   210

}

   211

   217

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

   218

/* 1.4.3 - Declaration & Initialisation */

   219

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

   220

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

   221

  TRACE("input_declarations_c");

   222

  current_param_direction = direction_in;

   223

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

   224

}

   225

   226

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

   227

   228

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

   229

   230

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

   231

  TRACE("en_param_declaration_c");

   232

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

   233

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

   234

   * variable list we will be analysing, the current_param_XXXX

   235

   * variables will get overwritten when we visit the next

   236

   * var1_init_decl_c list!

   237

   */

   240

  current_param_default_value = symbol->value;

   241

  current_param_type = symbol->type;

   242

   243

  return handle_single_param(symbol->name);

   244

}

   245

   246

/* var1_list ':' array_spec_init */

   247

//SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   248

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

   249

   250

/*  var1_list ':' initialized_structure */

   251

//SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   252

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

   253

   254

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

   255

  TRACE("output_declarations_c");

   256

  current_param_direction = direction_out;

   257

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

   258

}

   259

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

   260

  TRACE("eno_param_declaration_c");

   261

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

   262

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

   263

   * variable list we will be analysing, the current_param_XXXX

   264

   * variables will get overwritten when we visit the next

   265

   * var1_init_decl_c list!

   266

   */

   269

  current_param_default_value = NULL;

   270

  current_param_type = symbol->type;

   271

   272

  return handle_single_param(symbol->name);

   273

}

   274

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

   275

  TRACE("input_output_declarations_c");

   276

  current_param_direction = direction_inout;

   277

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

   278

}

   279

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

   280

   281

/*  var1_list ':' array_specification */

   282

//SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   283

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

   284

   285

/*  var1_list ':' structure_type_name */

   286

//SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name)

   287

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

   288

   289

/* VAR [CONSTANT] var_init_decl_list END_VAR */

   290

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

   291

   292

/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */

   293

/* option -> may be NULL ! */

   294

// SYM_REF2(external_var_declarations_c, option, external_declaration_list)

   295

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

   296

  TRACE("external_var_declarations_c");

   297

  current_param_direction = direction_extref;

   298

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

   299

}

   300

   301

/* helper symbol for external_var_declarations */

   302

/*| external_declaration_list external_declaration';' */

   303

// SYM_LIST(external_declaration_list_c)

   304

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

   305

   306

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

   307

//SYM_REF2(external_declaration_c, global_var_name, specification)

   308

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

   309

  TRACE("external_declaration_c");

   310

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

   311

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

   312

   * variable list we will be analysing, the current_param_XXXX

   313

   * variables will get overwritten when we visit the next

   314

   * var1_init_decl_c list!

   315

   */

   316

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

   317

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

   318

   319

  return handle_single_param(symbol->global_var_name);

   320

}

   321

   322

   323

#if 0

   324

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

   325

/* option -> may be NULL ! */

   326

SYM_REF2(global_var_declarations_c, option, global_var_decl_list)

   327

   328

/* helper symbol for global_var_declarations */

   329

/*| global_var_decl_list global_var_decl ';' */

   330

SYM_LIST(global_var_decl_list_c)

   331

   332

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

   333

/* type_specification ->may be NULL ! */

   334

SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   335

   336

/*| global_var_name location */

   337

SYM_REF2(global_var_spec_c, global_var_name, location)

   338

   339

/*  AT direct_variable */

   340

SYM_REF2(location_c, direct_variable, unused)

   341

   342

/*| global_var_list ',' global_var_name */

   343

SYM_LIST(global_var_list_c)

   344

   345

/*  var1_list ':' single_byte_string_spec */

   346

SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec)

   347

   348

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

   349

/* integer ->may be NULL ! */

   350

/* single_byte_character_string ->may be NULL ! */

   351

SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string)

   352

   353

/*  var1_list ':' double_byte_string_spec */

   354

SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec)

   355

   356

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

   357

/* integer ->may be NULL ! */

   358

/* double_byte_character_string ->may be NULL ! */

   359

SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string)

   360

   361

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

   362

/* option ->may be NULL ! */

   363

SYM_REF2(incompl_located_var_declarations_c, option, incompl_located_var_decl_list)

   364

   365

/* helper symbol for incompl_located_var_declarations */

   366

/*| incompl_located_var_decl_list incompl_located_var_decl ';' */

   367

SYM_LIST(incompl_located_var_decl_list_c)

   368

   369

/*  variable_name incompl_location ':' var_spec */

   370

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

   371

   372

/*  AT incompl_location_token */

   373

SYM_TOKEN(incompl_location_c)

   374

#endif

   375

   376

   377

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

   378

  TRACE("var1_init_decl_c");

   379

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

   380

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

   381

   * variable list we will be analysing, the current_param_XXXX

   382

   * variables will get overwritten when we visit the next

   383

   * var1_init_decl_c list!

   384

   */

   385

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

   386

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

   387

   388

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

   389

}

   390

   391

   392

   393

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

   394

  TRACE("var1_list_c");

   395

  return handle_param_list(symbol);

   396

}

   397

   398

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

   399

   400

   401

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

   402

/* B 1.5.1 - Functions */

   403

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

   404

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

   405

/* intermediate helper symbol for function_declaration */

   406

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

   407

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

   408

   409

   410

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

   411

/* B 1.5.2 - Function Blocks */

   412

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

   413

/*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   414

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

   415

   416

/* intermediate helper symbol for function_declaration */

   417

/*  { io_var_declarations | other_var_declarations }   */

   418

/*

   419

 * NOTE: we re-use the var_declarations_list_c

   420

 */

   421

   422

/*  VAR_TEMP temp_var_decl_list END_VAR */

   423

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

   424

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

   425

   426

/*  VAR NON_RETAIN var_init_decl_list END_VAR */

   427

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

   428

   429

   430

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

   431

/* B 1.5.3 - Programs */

   432

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

   433

/*  PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */

   434

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

   435

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

   436

   437

/* intermediate helper symbol for program_declaration_c */

   438

/*  { io_var_declarations | other_var_declarations }   */

   439

/*

   440

 * NOTE: we re-use the var_declarations_list_c

   441

 */

   442

   443

   444

   445

   446

   447