1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2009-2012  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2012       Manuele Conti (manuele.conti@sirius-es.it)

     6

 *  Copyright (C) 2012       Matteo Facchinetti (matteo.facchinetti@sirius-es.it)

     7

 *

     8

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

     9

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

    10

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

    11

 *  (at your option) any later version.

    12

 *

    13

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

    14

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

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16

 *  GNU General Public License for more details.

    17

 *

    18

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

    19

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

    20

 *

    21

 *

    22

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

    23

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

    24

 */

    25

    26

/*

    27

 * An IEC 61131-3 compiler.

    28

 *

    29

 * Based on the

    30

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

    31

 *

    32

 */

    33

    34

    35

/* TODO - things yet not checked by this data type checker...

    36

 *

    37

 * - check variable declarations

    38

 * - check data type declarations

    39

 * - check inside configurations (variable declarations)

    40

 * - check SFC code

    41

 * - must fix S and R IL functions (includes potientialy fixing stage4 code!) 

    42

 */

    43

    44

    45

/* NOTE: The algorithm implemented here assumes that flow control analysis has already been completed!

    46

 *       BEFORE running this visitor, be sure to CALL the flow_control_analysis_c visitor!

    47

 */

    48

    49

    50

/*

    51

 *  Fill the candidate datatype list for all symbols that may legally 'have' a data type (e.g. variables, literals, function calls, expressions, etc.)

    52

 * 

    53

 *  The candidate datatype list will be filled with a list of all the data types that expression may legally take.

    54

 *  For example, the very simple literal '0' (as in foo := 0), may represent a:

    55

 *    BOOL, BYTE, WORD, DWORD, LWORD, USINT, SINT, UINT, INT, UDINT, DINT, ULINT, LINT (as well as the SAFE versions of these data tyes too!)

    56

 */

    57

    58

#include <../main.hh>         /* required for UINT64_MAX, INT64_MAX, INT64_MIN, ... */

    59

#include "fill_candidate_datatypes.hh"

    60

#include "datatype_functions.hh"

    61

#include <typeinfo>

    62

#include <list>

    63

#include <string>

    64

#include <string.h>

    65

#include <strings.h>

    66

    67

#define GET_CVALUE(dtype, symbol)             ((symbol)->const_value._##dtype.value)

    68

#define VALID_CVALUE(dtype, symbol)           (symbol_c::cs_const_value == (symbol)->const_value._##dtype.status)

    69

#define IS_OVERFLOW(dtype, symbol)            (symbol_c::cs_overflow == (symbol)->const_value._##dtype.status)

    70

    71

/* set to 1 to see debug info during execution */

    72

static int debug = 0;

    73

    74

    75

    76

    77

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

    78

/*                                                   */

    79

/*  A small helper class...                          */

    80

/*                                                   */

    81

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

    82

    83

/* Add to the local_enumerated_value_symtable the local enum value constants */

    84

/* WARNING: This visitor expects to visit a POU (function, FB, program, ...)

    85

 *          It should not be called to visit any symbol that may include a TYPE .., END_TYPE declaration!

    86

 */

    87

/* Notes:

    88

 * Some enumerations are 

    89

 *   (A) declared anonymously inside a VAR ... END_VAR declaration

    90

 *       (e.g. VAR enum_var : (enumvalue1, enumvalue2); END_VAR)

    91

 *  while others are 

    92

 *   (B) declared (with a name) inside a TYPE .. END_TYPE declaration.

    93

 *

    94

 *  Values in (A) are added to the enumerated_value_symtable in absyntaxt_utils.cc.

    95

 *  Values in (B) are only in scope inside the POU with the VAR END_VAR declaration.

    96

 *

    97

 * This class will add the enum values in (B) to the local_enumerated_value_symtable.

    98

 *

    99

 * If a locally defined enum value is identical to another locally defined enum_value, the

   100

 *  corresponding entry in local_enumerated_value_symtable is set to NULL.

   101

 *  However, if a locally defined enum value is identical to another globally defined enum_value, the

   102

 *  corresponding entry in local_enumerated_value_symtable is set to the local datatype (and not NULL).

   103

 *  This is because anonynous locally feined enum datatypes are anonymous, and its enum values cannot therefore

   104

 *  be disambiguated using EnumType#enum_value (since the enum type does not have a name, it is anonymous!).

   105

 *  For this reason we implement the semantics where locally defined enum values, when in scope, will 'cover'

   106

 *  the globally defined enum value with the same name/identifier.

   107

 *  For example:

   108

 *

   109

 *  TYPE  GlobalEnumT: (xxx1, xxx2, xxx3) END_TYPE

   110

 * 

   111

 *   FUNCTION_BLOCK FOO

   112

 *    VAR_INPUT

   113

 *       GlobalEnumVar: GlobalEnumT;

   114

 *      LocalEnumVar : (xxx1, yyy2, yyy3);

   115

 *     END_VAR

   116

 *     LocalEnumVar  := xxx1;   <-- We consider it OK!!!     xxx1 will reference the anonymous type used for LocalEnumVar

   117

 *     GlobalEnumVar := xxx1;   <-- We consider it an error. xxx1 will reference the anonymous type used for LocalEnumVar

   118

 *     GlobalEnumVar := GlobalEnumT#xxx1;

   119

 *     END_FUNCTION_BLOCK

   120

 */

   121

   122

 symbol_c null_enumvalue_symbol; /* cannot be static, so it may be used in the template!! */

   123

 static symtable_c<symbol_c *, &null_enumvalue_symbol> local_enumerated_value_symtable;

   124

   125

   126

class populate_enumvalue_symtable_c: public iterator_visitor_c {

   127

  private:

   128

    symbol_c *current_enumerated_type;

   129

   130

  public:

   131

     populate_enumvalue_symtable_c(void) {current_enumerated_type = NULL;};

   132

    ~populate_enumvalue_symtable_c(void) {}

   133

   134

  public:

   135

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

   136

  /* B.1 - Common elements */

   137

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

   138

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

   139

  /* B.1.3 - Data types */

   140

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

   141

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

   142

  /* B 1.3.3 - Derived data types */

   143

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

   144

  /* enumerated_specification ASSIGN enumerated_value */

   145

  void *visit(enumerated_spec_init_c *symbol) {

   146

    current_enumerated_type = symbol;

   147

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

   148

    /* DO NOT visit the symbol->enumerated_value   !!! */

   149

    current_enumerated_type = NULL;

   150

    return NULL;

   151

  }

   152

   153

  /* [enumerated_type_name '#'] identifier */

   154

  void *visit(enumerated_value_c *symbol) {

   155

    /* if the enumerated_value_c is not inside a enumerated_spec_init_c (e.g. used as the inital value of a variable), we simply return */

   156

    if (current_enumerated_type == NULL) return NULL;  

   157

    /* this is really an ERROR! The initial value may use the syntax NUM_TYPE#enum_value, but in that case we should have return'd in the above statement !! */

   158

    if (symbol->type != NULL) ERROR;  

   159

   160

    // symbol_c *global_value_type =       enumerated_value_symtable.find_value(symbol->value);

   161

    symbol_c *local_value_type  = local_enumerated_value_symtable.find_value(symbol->value);

   162

    if (local_value_type == local_enumerated_value_symtable.end_value())

   163

      /* This identifier has not yet been used in any previous local declaration of an enumeration data type, so we add it to the local symbol table. */

   164

      local_enumerated_value_symtable.insert(symbol->value, current_enumerated_type);

   165

    else 

   166

      /* This identifier has already been used in a previous declaration of an enumeration data type. so we set the symbol in symbol table pointing to NULL. */

   167

      local_enumerated_value_symtable.set(symbol->value, NULL);

   168

    return NULL;

   169

  }

   170

}; // class populate_enumvalue_symtable_c

   171

   172

static populate_enumvalue_symtable_c populate_enumvalue_symtable;

   173

   174

   175

   176

   177

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

   178

/*                                                   */

   179

/*  Main  FILL candidate datatypes algorithm...      */

   180

/*                                                   */

   181

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

   182

   183

   184

   185

fill_candidate_datatypes_c::fill_candidate_datatypes_c(symbol_c *ignore) {

   186

	il_operand = NULL;

   187

	prev_il_instruction = NULL;

   188

	search_varfb_instance_type = NULL;

   190

}

   191

   192

fill_candidate_datatypes_c::~fill_candidate_datatypes_c(void) {

   193

}

   194

   195

symbol_c *fill_candidate_datatypes_c::widening_conversion(symbol_c *left_type, symbol_c *right_type, const struct widen_entry widen_table[]) {

   196

	int k;

   197

	/* find a widening table entry compatible */

   198

	for (k = 0; NULL != widen_table[k].left;  k++)

   199

		if ((typeid(*left_type) == typeid(*widen_table[k].left)) && (typeid(*right_type) == typeid(*widen_table[k].right)))

   200

                      return widen_table[k].result;

   201

	return NULL;

   202

}

   203

   204

   205

/* add a data type to a candidate data type list, while guaranteeing no duplicate entries! */

   206

/* Returns true if it really did add the datatype to the list, or false if it was already present in the list! */

   207

bool fill_candidate_datatypes_c::add_datatype_to_candidate_list(symbol_c *symbol, symbol_c *datatype) {

   208

  /* If it is an invalid data type, do not insert!

   209

   * NOTE: it reduces overall code size to do this test here, instead of doing every time before calling the add_datatype_to_candidate_list() function. 

   210

   */

   211

  if (!get_datatype_info_c::is_type_valid(datatype)) /* checks for NULL and invalid_type_name_c */

   212

    return false;

   213

   214

  if (search_in_candidate_datatype_list(datatype, symbol->candidate_datatypes) >= 0) 

   215

    /* already in the list, Just return! */

   216

    return false;

   217

   218

  /* not yet in the candidate data type list, so we insert it now! */

   219

  symbol->candidate_datatypes.push_back(datatype);

   220

  return true;

   221

}

   222

   223

   224

bool fill_candidate_datatypes_c::add_2datatypes_to_candidate_list(symbol_c *symbol, symbol_c *datatype1, symbol_c *datatype2) {

   225

  add_datatype_to_candidate_list(symbol, datatype1);

   226

  add_datatype_to_candidate_list(symbol, datatype2);

   227

  return true;

   228

}

   229

   230

   231

   232

void fill_candidate_datatypes_c::remove_incompatible_datatypes(symbol_c *symbol) {

   233

  #ifdef __REMOVE__

   234

    #error __REMOVE__ macro already exists. Choose another name!

   235

  #endif

   236

  #define __REMOVE__(datatype)\

   237

      remove_from_candidate_datatype_list(&get_datatype_info_c::datatype,       symbol->candidate_datatypes);\

   238

      remove_from_candidate_datatype_list(&get_datatype_info_c::safe##datatype, symbol->candidate_datatypes);

   239

   240

  {/* Remove unsigned data types */

   241

    uint64_t value = 0;

   242

    if (VALID_CVALUE( uint64, symbol)) value = GET_CVALUE(uint64, symbol);

   243

    if (IS_OVERFLOW ( uint64, symbol)) value = (uint64_t)UINT32_MAX + (uint64_t)1;

   244

   245

    if (value > 1          )          {__REMOVE__(bool_type_name);}

   246

    if (value > UINT8_MAX  )          {__REMOVE__(usint_type_name);  __REMOVE__( byte_type_name);}

   247

    if (value > UINT16_MAX )          {__REMOVE__( uint_type_name);  __REMOVE__( word_type_name);}

   248

    if (value > UINT32_MAX )          {__REMOVE__(udint_type_name);  __REMOVE__(dword_type_name);}

   249

    if (IS_OVERFLOW( uint64, symbol)) {__REMOVE__(ulint_type_name);  __REMOVE__(lword_type_name);}

   250

  }

   251

   252

  {/* Remove signed data types */

   253

    int64_t value = 0;

   254

    if (VALID_CVALUE(  int64, symbol)) value = GET_CVALUE(int64, symbol);

   255

    if (IS_OVERFLOW (  int64, symbol)) value = (int64_t)INT32_MAX + (int64_t)1;

   256

   257

    if ((value <  INT8_MIN) || (value >  INT8_MAX)) {__REMOVE__(sint_type_name);}

   258

    if ((value < INT16_MIN) || (value > INT16_MAX)) {__REMOVE__( int_type_name);}

   259

    if ((value < INT32_MIN) || (value > INT32_MAX)) {__REMOVE__(dint_type_name);}

   260

    if (IS_OVERFLOW( int64, symbol))                {__REMOVE__(lint_type_name);}

   261

  }

   262

   263

  {/* Remove floating point data types */

   264

    real64_t value = 0;

   265

    if (VALID_CVALUE( real64, symbol)) value = GET_CVALUE(real64, symbol);

   266

    if (IS_OVERFLOW ( real64, symbol)) value = (real64_t)REAL32_MAX + (real64_t)1;

   267

    if (value >  REAL32_MAX )         {__REMOVE__( real_type_name);}

   268

    if (value < -REAL32_MAX )         {__REMOVE__( real_type_name);}

   269

    if (IS_OVERFLOW( real64, symbol)) {__REMOVE__(lreal_type_name);}

   270

  }

   271

  #undef __REMOVE__

   272

}

   273

   274

   275

/* returns true if compatible function/FB invocation, otherwise returns false */

   276

/* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */

   277

/*

   278

 * All parameters being passed to the called function MUST be in the parameter list to which f_call points to!

   279

 * This means that, for non formal function calls in IL, de current (default value) must be artificially added to the

   280

 * beginning of the parameter list BEFORE calling handle_function_call().

   281

 */

   282

bool fill_candidate_datatypes_c::match_nonformal_call(symbol_c *f_call, symbol_c *f_decl) {

   283

	symbol_c *call_param_value,  *param_datatype;

   284

	identifier_c *param_name;

   285

	function_param_iterator_c       fp_iterator(f_decl);

   286

	function_call_param_iterator_c fcp_iterator(f_call);

   287

	int extensible_parameter_highest_index = -1;

   288

	unsigned int i;

   289

   290

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

   291

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

   292

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

   293

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

   294

		 */

   295

		do {

   296

			param_name = fp_iterator.next();

   297

			/* If there is no other parameter declared, then we are passing too many parameters... */

   298

			if(param_name == NULL) return false;

   299

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

   300

   301

		/* TODO: verify if it is lvalue when INOUT or OUTPUT parameters! */

   302

		/* Get the parameter type */

   303

		param_datatype = base_type(fp_iterator.param_type());

   304

   305

		/* check whether one of the candidate_data_types of the value being passed is the same as the param_type */

   306

		if (search_in_candidate_datatype_list(param_datatype, call_param_value->candidate_datatypes) < 0)

   307

			return false; /* return false if param_type not in the list! */

   308

	}

   309

	/* call is compatible! */

   310

	return true;

   311

}

   312

   313

   314

   315

/* returns true if compatible function/FB invocation, otherwise returns false */

   316

/* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */

   317

bool fill_candidate_datatypes_c::match_formal_call(symbol_c *f_call, symbol_c *f_decl, symbol_c **first_param_datatype) {

   318

	symbol_c *call_param_value, *call_param_name, *param_datatype;

   319

	symbol_c *verify_duplicate_param;

   320

	identifier_c *param_name;

   321

	function_param_iterator_c       fp_iterator(f_decl);

   322

	function_call_param_iterator_c fcp_iterator(f_call);

   323

	int extensible_parameter_highest_index = -1;

   324

	identifier_c *extensible_parameter_name;

   325

	unsigned int i;

   326

	bool is_first_param = true;

   327

   328

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

   329

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

   330

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

   331

		call_param_value = fcp_iterator.get_current_value();

   332

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

   333

		if (NULL == call_param_value) ERROR;

   334

   335

		/* Obtaining the assignment direction:  := (assign_in) or => (assign_out) */

   336

		function_call_param_iterator_c::assign_direction_t call_param_dir = fcp_iterator.get_assign_direction();

   337

   338

		/* Checking if there are duplicated parameter values */

   339

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   340

		if(verify_duplicate_param != call_param_value)

   341

			return false;

   342

   343

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

   344

		std::vector <symbol_c *>&call_param_types = call_param_value->candidate_datatypes;

   345

   346

		/* Find the corresponding parameter in function declaration */

   347

		param_name = fp_iterator.search(call_param_name);

   348

		if(param_name == NULL) return false;

   349

		/* Get the parameter data type */

   350

		param_datatype = base_type(fp_iterator.param_type());

   351

		/* Get the parameter direction: IN, OUT, IN_OUT */

   352

		function_param_iterator_c::param_direction_t param_dir = fp_iterator.param_direction();

   353

   354

		/* check whether direction (IN, OUT, IN_OUT) and assignment types (:= , =>) are compatible !!! */

   355

		if          (function_call_param_iterator_c::assign_in  == call_param_dir) {

   356

			if ((function_param_iterator_c::direction_in    != param_dir) &&

   357

			    (function_param_iterator_c::direction_inout != param_dir))

   358

				return false;

   359

		} else if   (function_call_param_iterator_c::assign_out == call_param_dir) {

   360

			if ((function_param_iterator_c::direction_out   != param_dir))

   361

				return false;

   362

		} else ERROR;

   363

   364

		/* check whether one of the candidate_data_types of the value being passed is the same as the param_type */

   365

		if (search_in_candidate_datatype_list(param_datatype, call_param_types) < 0)

   366

			return false; /* return false if param_type not in the list! */

   367

   368

		/* If this is the first parameter, then copy the datatype to *first_param_datatype */

   369

		if (is_first_param)

   370

			if (NULL != first_param_datatype)

   371

				*first_param_datatype = param_datatype;

   372

		is_first_param = false;

   373

	}

   374

	/* call is compatible! */

   375

	return true;

   376

}

   377

   378

   379

   380

   381

/* Handle a generic function call!

   382

 * Assumes that the parameter_list containing the values being passed in this function invocation

   383

 * has already had all the candidate_datatype lists filled in!

   384

 *

   385

 * All parameters being passed to the called function MUST be in the parameter list to which f_call points to!

   386

 * This means that, for non formal function calls in IL, de current (default value) must be artificially added to the

   387

 * beginning of the parameter list BEFORE calling handle_function_call().

   388

 */

   389

/*

   390

typedef struct {

   391

  symbol_c *function_name,

   392

  symbol_c *nonformal_operand_list,

   393

  symbol_c *   formal_operand_list,

   394

   395

  std::vector <symbol_c *> &candidate_functions,  

   396

  symbol_c &*called_function_declaration,

   397

  int      &extensible_param_count

   398

} generic_function_call_t;

   399

*/

   400

/*

   401

void narrow_candidate_datatypes_c::narrow_function_invocation(symbol_c *fcall, generic_function_call_t fcall_data) {

   402

void *fill_candidate_datatypes_c::handle_function_call(symbol_c *f_call, symbol_c *function_name, invocation_type_t invocation_type,

   403

                                                       std::vector <symbol_c *> *candidate_datatypes,

   404

                                                       std::vector <symbol_c *> *candidate_functions) {

   405

  */

   406

void fill_candidate_datatypes_c::handle_function_call(symbol_c *fcall, generic_function_call_t fcall_data) {

   407

	function_declaration_c *f_decl;

   408

	list_c *parameter_list;

   409

	list_c *parameter_candidate_datatypes;

   410

	symbol_c *returned_parameter_type;

   411

   412

	if (debug) std::cout << "function()\n";

   413

   414

	function_symtable_t::iterator lower = function_symtable.lower_bound(fcall_data.function_name);

   415

	function_symtable_t::iterator upper = function_symtable.upper_bound(fcall_data.function_name);

   416

	/* If the name of the function being called is not found in the function symbol table, then this is an invalid call */

   417

	/* Since the lexical parser already checks for this, then if this occurs then we have an internal compiler error. */

   418

	if (lower == function_symtable.end()) ERROR;

   419

   420

	/* Look for all compatible function declarations, and add their return datatypes 

   421

	 * to the candidate_datatype list of this function invocation. 

   422

	 *

   423

	 * If only one function exists, we add its return datatype to the candidate_datatype list,

   424

	 * even if the parameters passed to it are invalid.

   425

	 * This guarantees that the remainder of the expression in which the function call is inserted

   426

	 * is treated as if the function call returns correctly, and therefore does not generate

   427

	 * spurious error messages.

   428

	 * Even if the parameters to the function call are invalid, doing this is still safe, as the 

   429

	 * expressions inside the function call will themselves have erros and will  guarantee that 

   430

	 * compilation is aborted in stage3 (in print_datatypes_error_c).

   431

	 */

   432

	if (function_symtable.multiplicity(fcall_data.function_name) == 1) {

   433

		f_decl = function_symtable.get_value(lower);

   434

		returned_parameter_type = base_type(f_decl->type_name);

   435

		if (add_datatype_to_candidate_list(fcall, returned_parameter_type))

   436

			/* we only add it to the function declaration list if this entry was not already present in the candidate datatype list! */

   437

			fcall_data.candidate_functions.push_back(f_decl);

   438

   439

	}

   440

	for(; lower != upper; lower++) {

   441

		bool compatible = false;

   442

   443

		f_decl = function_symtable.get_value(lower);

   444

		/* Check if function declaration in symbol_table is compatible with parameters */

   445

		if (NULL != fcall_data.nonformal_operand_list) compatible=match_nonformal_call(fcall, f_decl);

   446

		if (NULL != fcall_data.   formal_operand_list) compatible=   match_formal_call(fcall, f_decl);

   447

		if (compatible) {

   448

			/* Add the data type returned by the called functions. 

   449

			 * However, only do this if this data type is not already present in the candidate_datatypes list_c

   450

			 */

   451

			returned_parameter_type = base_type(f_decl->type_name);		

   452

			if (add_datatype_to_candidate_list(fcall, returned_parameter_type))

   453

				/* we only add it to the function declaration list if this entry was not already present in the candidate datatype list! */

   454

				fcall_data.candidate_functions.push_back(f_decl);

   455

		}

   456

	}

   457

	if (debug) std::cout << "end_function() [" << fcall->candidate_datatypes.size() << "] result.\n";

   458

	return;

   459

}

   460

   461

   462

/* handle implicit FB call in IL.

   463

 * e.g.  CLK ton_var

   464

 *        CU counter_var

   465

 */

   466

void *fill_candidate_datatypes_c::handle_implicit_il_fb_call(symbol_c *il_instruction, const char *param_name, symbol_c *&called_fb_declaration) {

   467

	symbol_c *fb_type_id = search_varfb_instance_type->get_basetype_id(il_operand);

   468

  	/* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */

   469

	if (NULL == fb_type_id) ERROR;

   470

   471

	function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(fb_type_id);

   472

	if (function_block_type_symtable.end_value() == fb_decl)

   473

		/* The il_operand is not the name of a FB instance. Most probably it is the name of a variable of some other type.

   474

		 * this is a semantic error.

   475

		 */

   476

		fb_decl = NULL;

   477

   478

	/* The narrow_candidate_datatypes_c does not rely on this called_fb_declaration pointer being == NULL to conclude that

   479

	 * we have a datatype incompatibility error, so we set it to fb_decl to allow the print_datatype_error_c to print out

   480

	 * more informative error messages!

   481

	 */

   482

	called_fb_declaration = fb_decl;

   483

   484

	/* This implicit FB call does not change the value stored in the current/default IL variable */

   485

	/* It does, however, require that the datatype be compatible with the input parameter of the FB being called. 

   486

	 * If we were to follow the filling & narrowing algorithm correctly (implemented in fill_candidate_datatypes_c

   487

	 * & narrow_candidate_datatypes_c respectively), we should be restricting the candidate_datatpes to the datatypes

   488

	 * that are compatible to the FB call. 

   489

	 * However, doing the above will often result in some very confusing error messages for the user, especially in the case

   490

	 * in which the FB call is wrong, so the resulting cadidate datatypes is an empty list. In this case, the user would see

   491

	 * many error messages related to the IL instructions that follow the FB call, even though those IL instructions may be perfectly

   492

	 * correct.

   493

	 * For now, we will simply let the narrow_candidate_datatypes_c verify if the datatypes are compatible (something that should be done

   494

	 * here).

   495

	 */

   496

	if (NULL != prev_il_instruction)