1

/*

     2

 * (c) 2009 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

/* Verify whether the semantic rules of data type compatibility are being followed.

    27

 *

    28

 * For example:

    29

 */

    30

    31

#include "visit_expression_type.hh"

    32

#include <typeinfo>

    33

#include <list>

    34

#include <string>

    35

#include <string.h>

    36

#include <strings.h>

    37

    38

    39

    40

#define FIRST_(symbol1, symbol2) (((symbol1)->first_line   < (symbol2)->first_line)   ? (symbol1) :    \

    41

                                  ((symbol1)->first_line   > (symbol2)->first_line)   ? (symbol2) :    \

    42

                                  ((symbol1)->first_column < (symbol2)->first_column) ? (symbol1) :    \

    43

                                  ((symbol1)->first_column > (symbol2)->first_column) ? (symbol2) :    \

    44

                                  (symbol1))

    45

    46

#define  LAST_(symbol1, symbol2) (((symbol1)->last_line    < (symbol2)->last_line)    ? (symbol2) :    \

    47

                                  ((symbol1)->last_line    > (symbol2)->last_line)    ? (symbol1) :    \

    48

                                  ((symbol1)->last_column  < (symbol2)->last_column)  ? (symbol2) :    \

    49

                                  ((symbol1)->last_column  > (symbol2)->last_column)  ? (symbol1) :    \

    50

                                  (symbol1))

    51

    52

#define STAGE3_ERROR(symbol1, symbol2, msg) {                                          \

    53

    printf("semantic error between (%d:%d) and (%d:%d): %s\n",                         \

    54

           FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column, \

    55

           LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column,  \

    56

           msg);                                                                       \

    57

    il_error = true;                                                                   \

    58

  }

    59

    60

    61

    62

    63

    64

void *visit_expression_type_c::visit(program_declaration_c *symbol) {

    65

  search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    66

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

    67

  printf("checking semantics in body of program %s\n", ((token_c *)(symbol->program_type_name))->value);

    68

  il_parenthesis_level = 0;

    69

  il_error = false;

    70

  il_default_variable_type = NULL;

    71

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

    72

  il_default_variable_type = NULL;

    73

  delete search_varfb_instance_type;

    74

  return NULL;

    75

}

    76

    77

void *visit_expression_type_c::visit(function_declaration_c *symbol) {

    78

  search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    79

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

    80

  printf("checking semantics in body of function %s\n", ((token_c *)(symbol->derived_function_name))->value);

    81

  il_parenthesis_level = 0;

    82

  il_error = false;

    83

  il_default_variable_type = NULL;

    84

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

    85

  il_default_variable_type = NULL;

    86

  delete search_varfb_instance_type;

    87

  return NULL;

    88

}

    89

    90

void *visit_expression_type_c::visit(function_block_declaration_c *symbol) {

    91

  search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    92

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

    93

  printf("checking semantics in body of FB %s\n", ((token_c *)(symbol->fblock_name))->value);

    94

  il_parenthesis_level = 0;

    95

  il_error = false;

    96

  il_default_variable_type = NULL;

    97

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

    98

  il_default_variable_type = NULL;

    99

  delete search_varfb_instance_type;

   100

  return NULL;

   101

}

   102

   103

   104

   105

   106

   107

   108

   109

   110

   111

visit_expression_type_c::visit_expression_type_c(symbol_c *search_scope) {

   112

}

   113

   114

visit_expression_type_c::~visit_expression_type_c(void) {

   115

}

   116

   117

   118

/* A helper function... */

   119

bool visit_expression_type_c::is_ANY_ELEMENTARY_type(symbol_c *type_symbol) {

   120

  if (type_symbol == NULL) {ERROR;}

   121

  return is_ANY_MAGNITUDE_type(type_symbol)

   122

      || is_ANY_BIT_type(type_symbol)

   123

      || is_ANY_STRING_type(type_symbol)

   124

      || is_ANY_DATE_type(type_symbol);

   125

}

   126

   127

   128

/* A helper function... */

   129

bool visit_expression_type_c::is_ANY_MAGNITUDE_type(symbol_c *type_symbol) {

   130

  if (type_symbol == NULL) {ERROR;}

   131

  if (typeid(*type_symbol) == typeid(time_type_name_c)) {return true;}

   132

  return is_ANY_NUM_type(type_symbol);

   133

}

   134

   135

   136

/* A helper function... */

   137

bool visit_expression_type_c::is_ANY_NUM_type(symbol_c *type_symbol) {

   138

  if (type_symbol == NULL) {ERROR;}

   139

  return is_ANY_REAL_type(type_symbol) || is_ANY_INT_type(type_symbol);

   140

}

   141

   142

   143

/* A helper function... */

   144

bool visit_expression_type_c::is_ANY_DATE_type(symbol_c *type_symbol) {

   145

  if (type_symbol == NULL) {ERROR;}

   146

  if (typeid(*type_symbol) == typeid(date_type_name_c)) {return true;}

   147

  if (typeid(*type_symbol) == typeid(tod_type_name_c)) {return true;}

   148

  if (typeid(*type_symbol) == typeid(dt_type_name_c)) {return true;}

   149

  return false;

   150

}

   151

   152

   153

/* A helper function... */

   154

bool visit_expression_type_c::is_ANY_STRING_type(symbol_c *type_symbol) {

   155

  if (type_symbol == NULL) {ERROR;}

   156

  if (typeid(*type_symbol) == typeid(string_type_name_c)) {return true;}

   157

  if (typeid(*type_symbol) == typeid(wstring_type_name_c)) {return true;}

   158

  return false;

   159

}

   160

   161

   162

/* A helper function... */

   163

bool visit_expression_type_c::is_ANY_INT_type(symbol_c *type_symbol) {

   164

  if (type_symbol == NULL) {ERROR;}

   165

  if (typeid(*type_symbol) == typeid(sint_type_name_c))  {return true;}

   166

  if (typeid(*type_symbol) == typeid(int_type_name_c))   {return true;}

   167

  if (typeid(*type_symbol) == typeid(dint_type_name_c))  {return true;}

   168

  if (typeid(*type_symbol) == typeid(lint_type_name_c))  {return true;}

   169

  if (typeid(*type_symbol) == typeid(usint_type_name_c)) {return true;}

   170

  if (typeid(*type_symbol) == typeid(uint_type_name_c))  {return true;}

   171

  if (typeid(*type_symbol) == typeid(udint_type_name_c)) {return true;}

   172

  if (typeid(*type_symbol) == typeid(ulint_type_name_c)) {return true;}

   173

  if (is_literal_integer_type(type_symbol))              {return true;}

   174

  return false;

   175

}

   176

   177

   178

/* A helper function... */

   179

bool visit_expression_type_c::is_ANY_REAL_type(symbol_c *type_symbol) {

   180

  if (type_symbol == NULL) {ERROR;}

   181

  if (typeid(*type_symbol) == typeid(real_type_name_c))  {return true;}

   182

  if (typeid(*type_symbol) == typeid(lreal_type_name_c)) {return true;}

   183

  if (is_literal_real_type(type_symbol))                 {return true;}

   184

  return false;

   185

}

   186

   187

   188

/* A helper function... */

   189

bool visit_expression_type_c::is_ANY_BIT_type(symbol_c *type_symbol) {

   190

  if (type_symbol == NULL) {ERROR;}

   191

  if (typeid(*type_symbol) == typeid(bool_type_name_c))  {return true;}

   192

  if (typeid(*type_symbol) == typeid(byte_type_name_c))  {return true;}

   193

  if (typeid(*type_symbol) == typeid(word_type_name_c))  {return true;}

   194

  if (typeid(*type_symbol) == typeid(dword_type_name_c)) {return true;}

   195

  if (typeid(*type_symbol) == typeid(lword_type_name_c)) {return true;}

   196

  if (is_literal_integer_type(type_symbol))              {return true;}

   197

  return false;

   198

}

   199

   200

   201

/* A helper function... */

   202

bool visit_expression_type_c::is_BOOL_type(symbol_c *type_symbol) {

   203

  if (type_symbol == NULL) {ERROR;}

   204

  if (typeid(*type_symbol) == typeid(bool_type_name_c))  {return true;}

   205

  if (is_literal_bool_type(type_symbol))                 {return true;}

   206

  return false;

   207

}

   208

   209

   210

#define sizeoftype(symbol) get_sizeof_datatype_c::getsize(symbol)

   211

   212

   213

/* A helper function... */

   214

bool visit_expression_type_c::is_literal_integer_type(symbol_c *type_symbol) {

   215

  if (type_symbol == NULL) {return true;}

   216

  if (typeid(*type_symbol) == typeid(integer_c))        {return true;}

   217

  if (typeid(*type_symbol) == typeid(binary_integer_c)) {return true;}

   218

  if (typeid(*type_symbol) == typeid(octal_integer_c))  {return true;}

   219

  if (typeid(*type_symbol) == typeid(hex_integer_c))    {return true;}

   220

  return false;

   221

}

   222

   223

   224

/* A helper function... */

   225

bool visit_expression_type_c::is_literal_real_type(symbol_c *type_symbol) {

   226

  if (type_symbol == NULL) {return true;}

   227

  if (typeid(*type_symbol) == typeid(real_c)) {return true;}

   228

  return false;

   229

}

   230

   231

   232

/* A helper function... */

   233

bool visit_expression_type_c::is_literal_bool_type(symbol_c *type_symbol) {

   234

  bool_type_name_c bool_t;

   235

   236

  if (type_symbol == NULL) {return true;}

   237

  if (typeid(*type_symbol) == typeid(boolean_true_c))    {return true;}

   238

  if (typeid(*type_symbol) == typeid(boolean_false_c))   {return true;}

   239

  if (is_literal_integer_type(type_symbol))

   240

    if (sizeoftype(&bool_t) >= sizeoftype(type_symbol))  {return true;}

   241

  return false;

   242

}

   243

   244

   245

/* Determine the common data type between two data types.

   246

 * If no common data type found, return NULL.

   247

 *

   248

 * If data types are identical, return the first (actually any would do...).

   249

 * If any of the data types is a literal, we confirm that 

   250

 *   the literal uses less bits than the fixed size data type.

   251

 *   e.g. BYTE and 1024 returns NULL

   252

 *        BYTE and 255  returns BYTE

   253

 *

   254

 * If two literals, then return the literal that requires more bits...

   255

 */

   256

symbol_c *visit_expression_type_c::common_type__(symbol_c *first_type, symbol_c *second_type) {

   257

  if (first_type == NULL && second_type == NULL) {ERROR;}

   258

  if (first_type == NULL)  {return second_type;}

   259

  if (second_type == NULL) {return first_type;}

   260

   261

  if (is_literal_integer_type(first_type) && is_literal_integer_type(second_type))

   262

    {return ((sizeoftype(first_type) > sizeoftype(second_type))? first_type:second_type);}

   263

   264

  if (is_literal_real_type(first_type) && is_literal_real_type(second_type))

   265

    {return ((sizeoftype(first_type) > sizeoftype(second_type))? first_type:second_type);}

   266

   267

  if (is_literal_bool_type(first_type) && is_literal_bool_type(second_type))

   268

    {return first_type;}

   269

   270

  /* This check can only be made after the is_literal_XXXX checks */

   271

  /* When two literals of the same type, with identical typeid's are checked,

   272

   * we must return the one that occupies more bits...

   273

   */

   274

  if (typeid(*first_type) == typeid(*second_type)) {return first_type;}

   275

   276

  if (is_BOOL_type(first_type)      && is_literal_bool_type(second_type))     {return first_type;}

   277

  if (is_BOOL_type(second_type)     && is_literal_bool_type(first_type))      {return second_type;}

   278

   279

  if (is_ANY_BIT_type(first_type)     && is_literal_integer_type(second_type))

   280

    {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   281

  if (is_ANY_BIT_type(second_type)    && is_literal_integer_type(first_type))

   282

    {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   283

   284

  if (is_ANY_INT_type(first_type)   && is_literal_integer_type(second_type))

   285

    {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   286

  if (is_ANY_INT_type(second_type)  && is_literal_integer_type(first_type))

   287

    {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   288

   289

  if (is_ANY_REAL_type(first_type)  && is_literal_real_type(second_type))

   290

    {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   291

  if (is_ANY_REAL_type(second_type) && is_literal_real_type(first_type))

   292

    {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   293

   294

  /* no common type */

   295

  return NULL;

   296

}

   297

   298

/* Determine the common data type between two data types.

   299

 * Unlike the common_type__() function, we stop the compiler with an ERROR

   300

 *  if no common data type is found.

   301

 */

   302

symbol_c *visit_expression_type_c::common_type(symbol_c *first_type, symbol_c *second_type) {

   303

  symbol_c *res = common_type__(first_type, second_type);

   304

  if (NULL == res) ERROR;

   305

  return res;

   306

}

   307

   308

   309

/* Return TRUE if there is a common data type, otherwise return FALSE

   310

 */

   311

bool visit_expression_type_c::is_compatible_type(symbol_c *first_type, symbol_c *second_type) {

   312

  if (first_type == NULL || second_type == NULL) {ERROR;}

   313

  return (NULL != common_type__(first_type, second_type));

   314

}

   315

   316

   317

   318

#define is_num_type      is_ANY_NUM_type

   319

#define is_integer_type  is_ANY_INT_type

   320

#define is_real_type     is_ANY_REAL_type

   321

#define is_binary_type   is_ANY_BIT_type

   322

 /* actually the ROR, ROL, SHL, and SHR function also accept boolean type! */

   323

#define is_nbinary_type  is_ANY_BIT_type  

   324

#define compute_standard_function_default visit_expression_type_c::compute_standard_function_default

   325

#define compute_standard_function_il visit_expression_type_c::compute_standard_function_il

   326

#define search_expression_type_c visit_expression_type_c

   327

#define search(x) search_f(x)

   328

#define next() next_nf()

   329

//     #define search_constant_type_c::constant_int_type_name  search_expression_type_c::integer

   330

#define constant_int_type_name  integer

   331

#define is_same_type is_compatible_type

   332

#include "../absyntax_utils/search_type_code.c"

   333

#undef is_same_type

   334

#undef constant_int_type_name

   335

//     #undef search_constant_type_c::constant_int_type_name

   336

#undef next

   337

#undef search

   338

#undef compute_standard_function_default

   339

#undef compute_standard_function_il

   340

#undef search_expression_type_c

   341

#undef is_real_type

   342

#undef is_binary_type

   343

#undef is_nbinary_type

   344

#undef is_integer_type

   345

#undef is_num_type

   346

   347

   348

   349

   350

   351

   352

/* A helper function... */

   353

symbol_c *visit_expression_type_c::compute_boolean_expression(symbol_c *left_type, symbol_c *right_type,

   354

                                                              is_data_type_t is_data_type) {

   355

  bool error = false;

   356

   357

  if (!(this->*is_data_type)(left_type)) {

   358

    STAGE3_ERROR(left_type, left_type, "invalid data type of first operand.");

   359

    error = true;

   360

  }

   361

  if (!(this->*is_data_type)(right_type)) {

   362

    STAGE3_ERROR(right_type, right_type, "invalid data type of second operand.");

   363

    error = true;

   364

  }

   365

  if (!is_compatible_type(left_type, right_type)) {

   366

    STAGE3_ERROR(left_type, right_type, "type mismatch between operands.");

   367

    error = true;

   368

  }

   369

   370

  if (error)

   371

    return NULL;

   372

  else

   373

    return common_type(left_type, right_type);

   374

}

   375

   376

   377

/* A helper function... */

   378

symbol_c *visit_expression_type_c::compute_numeric_expression(symbol_c *left_type, symbol_c *right_type,

   379

                                                              is_data_type_t is_data_type) {

   380

  if (!(this->*is_data_type)(left_type))

   381

    STAGE3_ERROR(left_type, right_type, "Both parts of the equation must be the same type.");

   382

  if (!(this->*is_data_type)(right_type))

   383

    STAGE3_ERROR(left_type, right_type, "Both parts of the equation must be the same type.");

   384

  if (!is_compatible_type(left_type, right_type))

   385

    STAGE3_ERROR(left_type, right_type, "Both parts of the equation must be the same type.");

   386

   387

  if (is_literal_integer_type(left_type) || is_literal_real_type(left_type)) {

   388

    return right_type;

   389

  } else {

   390

    return left_type;

   391

  }

   392

   393

  /* humour the compiler... */

   394

  return NULL;

   395

}

   396

   397

   398

   399

   400

   401

   402

/* A helper function... */

   403

/* check the semantics of a FB or Function non-formal call */

   404

/* e.g. foo(1, 2, 3, 4);  */

   405

void visit_expression_type_c::check_nonformal_call(symbol_c *f_call, symbol_c *f_decl, bool use_il_defvar) {

   406

  symbol_c *call_param_value, *call_param_type, *param_type;

   407

  identifier_c *param_name;

   408

  function_param_iterator_c       fp_iterator(f_decl);

   409

  function_call_param_iterator_c fcp_iterator(f_call);

   410

   411

  /* if use_il_defvar, then the first parameter for the call comes from the il_default_variable */

   412

  if (use_il_defvar) {

   413

    /* The first parameter of the function corresponds to the il_default_variable_type of the function call */

   414

    do {

   415

      param_name = fp_iterator.next();

   416

      if(param_name == NULL) break;

   417

      /*  The EN and ENO parameters are default parameters.

   418

       *  In the non-formal invocation of a function there can be no assignment of

   419

       * values to these parameters. Therefore, we ignore the parameters declared

   420

       * in the function.

   421

       */

   422

    } while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0));

   423

    /* If the function does not have any parameters (param_name == NULL)

   424

     * then we cannot compare its type with the il_default_variable_type.

   425

     */

   426

    if(param_name != NULL) {

   427

      param_type = fp_iterator.param_type();

   428

      if(!is_compatible_type(il_default_variable_type,param_type)) 

   429

        STAGE3_ERROR(f_call, f_call, "In function/FB call, first parameter has invalid data type.");

   430

    }

   431

  } // if (use_il_defvar)

   432

   433

  /* Iterating through the non-formal parameters of the function call */

   434

  while((call_param_value = fcp_iterator.next_nf()) != NULL) {

   435

    /* Obtaining the type of the current parameter in the function call */

   436

    call_param_type = base_type((symbol_c*)call_param_value->accept(*this));

   437

    if (call_param_type == NULL) STAGE3_ERROR(call_param_value, call_param_value, "Could not determine data type of value being passed in function/FB call.");;

   438

   439

    /* Iterate to the next parameter of the function being called.

   440

     * Get the name of that parameter, and ignore if EN or ENO.

   441

     */

   442

    do {

   443

      param_name = fp_iterator.next();

   444

      /* If there is no parameter declared with that name */

   445

      if(param_name == NULL) {STAGE3_ERROR(f_call, f_call, "Too many parameters in function/FB call."); break;}

   446

    } while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0));

   447

   448

    if(param_name != NULL) {

   449

      /* Get the parameter type */

   450

      param_type = fp_iterator.param_type();

   451

      /* If the declared parameter and the parameter from the function call do no have the same type */

   452

      if(!is_compatible_type(call_param_type,param_type)) STAGE3_ERROR(call_param_value, call_param_value, "Type mismatch in function/FB call parameter.");

   453

    }

   454

  }

   455

}

   456

   457

void visit_expression_type_c::compute_input_operatores(symbol_c *symbol, const char *input_operator){

   458

  symbol_c *call_param_type;

   459

  symbol_c *fb_decl = il_operand_type;

   460

    /* The following should never occur. The function block must be defined, 

   461

     * and the FB type being called MUST be in the symtable... 

   462

     * This was all already checked at stage 2!

   463

     */

   464

  if (NULL == fb_decl){ 

   465

    STAGE3_ERROR(symbol, symbol, "Parameter operator needs an instance of a function block operand.");

   466

    ERROR;

   467

  }

   468

   469

   /* Iterating through the formal parameters of the function call */

   470

  identifier_c call_param_name(input_operator);

   471

   472

  /* Obtaining the type of the value being passed in the function call */

   473

  call_param_type = il_default_variable_type;

   474

  if (call_param_type == NULL) {

   475

    STAGE3_ERROR(&call_param_name, &call_param_name, "Could not determine data type of value being passed in function/FB call.");

   476

    /* The data value being passed is possibly any enumerated type value.

   477

     * We do not yet handle semantic verification of enumerated types.

   478

     */

   479

    ERROR;

   480

  }

   481

  call_param_type = base_type(call_param_type);

   482

  if (call_param_type == NULL) STAGE3_ERROR(&call_param_name, &call_param_name, "Could not determine data type of value being passed in function/FB call.");

   483

   484

   485

  check_formal_parameter(&call_param_name, call_param_type, fb_decl);

   486

//   return NULL;

   487

}

   488

   489

void visit_expression_type_c::check_formal_parameter(symbol_c *call_param_name, symbol_c *call_param_type, symbol_c *f_decl) {

   490

  symbol_c *param_type;

   491

  identifier_c *param_name;

   492

  function_param_iterator_c       fp_iterator(f_decl);

   493

   494

  /* Find the corresponding parameter of the function being called */

   495

  param_name = fp_iterator.search(call_param_name);

   496

  if(param_name == NULL) {

   497

    STAGE3_ERROR(call_param_name, call_param_name, "Invalid parameter in function/FB call.");

   498

  } else {

   499

    /* Get the parameter type */

   500

    param_type = fp_iterator.param_type();

   501

    /* If the declared parameter and the parameter from the function call have the same type */

   502

//     if(!is_compatible_type(call_param_type, param_type)) STAGE3_ERROR(call_param_name, call_param_value, "Type mismatch function/FB call parameter.");

   503

    if(!is_compatible_type(call_param_type, param_type)) STAGE3_ERROR(call_param_name, call_param_name, "Type mismatch function/FB call parameter.");

   504

  }

   505

}

   506

   507

   508

/* A helper function... */

   509

/* check the semantics of a FB or Function formal call */

   510

/* e.g. foo(IN1 := 1, OUT1 =>x, EN := true);  */

   511

void visit_expression_type_c::check_formal_call(symbol_c *f_call, symbol_c *f_decl) {

   512

  symbol_c *call_param_value, *call_param_type, *call_param_name, *param_type;

   513

  symbol_c *verify_duplicate_param;

   514

  identifier_c *param_name;

   515

  function_param_iterator_c       fp_iterator(f_decl);

   516

  function_call_param_iterator_c fcp_iterator(f_call);

   517

   518

  /* Iterating through the formal parameters of the function call */

   519

  while((call_param_name = fcp_iterator.next_f()) != NULL) {

   520

   521

    /* Obtaining the value being passed in the function call */

   522

    call_param_value = fcp_iterator.get_current_value();

   523

    /* the following should never occur. If it does, then we have a bug in our code... */

   524

    if (NULL == call_param_value) ERROR;

   525

   526

    /* Checking if there are duplicated parameter values */

   527

    verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   528

    if(verify_duplicate_param != call_param_value){

   529

      STAGE3_ERROR(call_param_name, verify_duplicate_param, "Duplicated parameter values.");

   530