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

    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 IS_UNDEF(dtype, symbol)               (NULL == (symbol)->const_value_##dtype)

    69

#define VALID_CVALUE(dtype, symbol)           ((NULL != (symbol)->const_value_##dtype) && (symbol_c::cs_const_value == (symbol)->const_value_##dtype->status))

    70

#define IS_OVERFLOW(dtype, symbol)            (symbol_c::cs_overflow == (symbol)->const_value_##dtype->status)

    71

    72

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

    73

static int debug = 0;

    74

    75

fill_candidate_datatypes_c::fill_candidate_datatypes_c(symbol_c *ignore) {

    76

}

    77

    78

fill_candidate_datatypes_c::~fill_candidate_datatypes_c(void) {

    79

}

    80

    81

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

    82

	int k;

    83

	/* find a widening table entry compatible */

    84

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

    85

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

    86

                      return widen_table[k].result;

    87

	return NULL;

    88

}

    89

    90

    91

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

    92

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

    93

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

    94

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

    95

   * 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. 

    96

   */

    97

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

    98

    return false;

    99

   100

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

   101

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

   102

    return false;

   103

   104

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

   105

  symbol->candidate_datatypes.push_back(datatype);

   106

  return true;

   107

}

   108

   109

   110

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

   111

  add_datatype_to_candidate_list(symbol, datatype1);

   112

  add_datatype_to_candidate_list(symbol, datatype2);

   113

  return true;

   114

}

   115

   116

void fill_candidate_datatypes_c::remove_incompatible_datatypes(symbol_c *symbol) {

   117

  /* Remove unsigned data types */

   118

  if (! IS_UNDEF( uint64, symbol)) {

   119

    if (VALID_CVALUE( uint64, symbol)) {

   120

      uint64_t value = GET_CVALUE(uint64, symbol);

   121

      if (value > 1) {

   122

    	  remove_from_candidate_datatype_list(&search_constant_type_c::bool_type_name,       symbol->candidate_datatypes);

   123

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safebool_type_name,   symbol->candidate_datatypes);

   124

      }

   125

      if (value > UINT8_MAX  ) {

   126

    	  remove_from_candidate_datatype_list(&search_constant_type_c::usint_type_name,      symbol->candidate_datatypes);

   127

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safeusint_type_name,  symbol->candidate_datatypes);

   128

	      remove_from_candidate_datatype_list(&search_constant_type_c::byte_type_name,       symbol->candidate_datatypes);

   129

	      remove_from_candidate_datatype_list(&search_constant_type_c::safebyte_type_name,   symbol->candidate_datatypes);

   130

      }

   131

      if (value > UINT16_MAX ) {

   132

    	  remove_from_candidate_datatype_list(&search_constant_type_c::uint_type_name,       symbol->candidate_datatypes);

   133

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safeuint_type_name,   symbol->candidate_datatypes);

   134

          remove_from_candidate_datatype_list(&search_constant_type_c::word_type_name,       symbol->candidate_datatypes);

   135

          remove_from_candidate_datatype_list(&search_constant_type_c::safeword_type_name,   symbol->candidate_datatypes);

   136

      }

   137

      if (value > UINT32_MAX ) {

   138

    	  remove_from_candidate_datatype_list(&search_constant_type_c::udint_type_name,      symbol->candidate_datatypes);

   139

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safeudint_type_name,  symbol->candidate_datatypes);

   140

          remove_from_candidate_datatype_list(&search_constant_type_c::dword_type_name,      symbol->candidate_datatypes);

   141

          remove_from_candidate_datatype_list(&search_constant_type_c::safedword_type_name,  symbol->candidate_datatypes);

   142

      }

   143

    }

   144

    if (IS_OVERFLOW( uint64, symbol)) {

   163

    }

   164

  }

   165

  /* Remove signed data types */

   166

  if (! IS_UNDEF( int64, symbol)) {

   167

 	if (VALID_CVALUE( int64, symbol)) {

   168

      int64_t value = GET_CVALUE(int64, symbol);

   169

      if (value < 0 || value > 1) {

   170

    	  remove_from_candidate_datatype_list(&search_constant_type_c::bool_type_name,       symbol->candidate_datatypes);

   171

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safebool_type_name,   symbol->candidate_datatypes);

   172

      }

   173

 	  if  ((value < INT8_MIN  ) || (value > INT8_MAX )) {

   174

 	      remove_from_candidate_datatype_list(&search_constant_type_c::sint_type_name,       symbol->candidate_datatypes);

   175

 	      remove_from_candidate_datatype_list(&search_constant_type_c::safesint_type_name,   symbol->candidate_datatypes);

   176

	      remove_from_candidate_datatype_list(&search_constant_type_c::byte_type_name,       symbol->candidate_datatypes);

   177

	      remove_from_candidate_datatype_list(&search_constant_type_c::safebyte_type_name,   symbol->candidate_datatypes);

   178

 	  }

   179

      if  ((value < INT16_MIN ) || (value > INT16_MAX)) {

   180

          remove_from_candidate_datatype_list(&search_constant_type_c::int_type_name,        symbol->candidate_datatypes);

   181

          remove_from_candidate_datatype_list(&search_constant_type_c::safeint_type_name,    symbol->candidate_datatypes);

   182

          remove_from_candidate_datatype_list(&search_constant_type_c::word_type_name,       symbol->candidate_datatypes);

   183

          remove_from_candidate_datatype_list(&search_constant_type_c::safeword_type_name,   symbol->candidate_datatypes);

   184

      }

   185

      if  ((value < INT32_MIN ) || (value > INT32_MAX)) {

   186

          remove_from_candidate_datatype_list(&search_constant_type_c::dint_type_name,       symbol->candidate_datatypes);

   187

          remove_from_candidate_datatype_list(&search_constant_type_c::safedint_type_name,   symbol->candidate_datatypes);

   188

          remove_from_candidate_datatype_list(&search_constant_type_c::dword_type_name,      symbol->candidate_datatypes);

   189

          remove_from_candidate_datatype_list(&search_constant_type_c::safedword_type_name,  symbol->candidate_datatypes);

   190

      }

   191

 	}

   192

    if  (IS_OVERFLOW( int64, symbol)) {

   193

    	  /* Not exist a valid signed integer data types it can represent the current value */

   194

    	  remove_from_candidate_datatype_list(&search_constant_type_c::sint_type_name,       symbol->candidate_datatypes);

   195

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safesint_type_name,   symbol->candidate_datatypes);

   196

    	  remove_from_candidate_datatype_list(&search_constant_type_c::int_type_name,        symbol->candidate_datatypes);

   197

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safeint_type_name,    symbol->candidate_datatypes);

   198

    	  remove_from_candidate_datatype_list(&search_constant_type_c::dint_type_name,       symbol->candidate_datatypes);

   199

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safedint_type_name,   symbol->candidate_datatypes);

   200

    	  remove_from_candidate_datatype_list(&search_constant_type_c::lint_type_name,       symbol->candidate_datatypes);

   201

    	  remove_from_candidate_datatype_list(&search_constant_type_c::safelint_type_name,   symbol->candidate_datatypes);

   202

	      remove_from_candidate_datatype_list(&search_constant_type_c::byte_type_name,       symbol->candidate_datatypes);

   203

	      remove_from_candidate_datatype_list(&search_constant_type_c::safebyte_type_name,   symbol->candidate_datatypes);

   204

          remove_from_candidate_datatype_list(&search_constant_type_c::word_type_name,       symbol->candidate_datatypes);

   205

          remove_from_candidate_datatype_list(&search_constant_type_c::safeword_type_name,   symbol->candidate_datatypes);

   206

          remove_from_candidate_datatype_list(&search_constant_type_c::dword_type_name,      symbol->candidate_datatypes);

   207

          remove_from_candidate_datatype_list(&search_constant_type_c::safedword_type_name,  symbol->candidate_datatypes);

   208

          remove_from_candidate_datatype_list(&search_constant_type_c::lword_type_name,      symbol->candidate_datatypes);

   209

          remove_from_candidate_datatype_list(&search_constant_type_c::safelword_type_name,  symbol->candidate_datatypes);

   210

    }

   211

  }

   212

  /* Remove floating point data types */

   213

  if (! IS_UNDEF( real64, symbol)) {

   214

	  if (VALID_CVALUE( real64, symbol)) {

   215

		  real64_t value = GET_CVALUE(real64, symbol);

   216

		  /*  We need a way to understand when lost precision happen and overflow for single precision.

   217

		   *  In this way we can remove REAL data type when a value has a mantissa or exponent too large.

   218

		   */

   219

	  }

   220

	  if  (IS_OVERFLOW( real64, symbol)) {

   221

		  /* Not exist a valid real data types that it can represent the current value */

   222

	      remove_from_candidate_datatype_list(&search_constant_type_c::real_type_name,      symbol->candidate_datatypes);

   223

	      remove_from_candidate_datatype_list(&search_constant_type_c::safereal_type_name,  symbol->candidate_datatypes);

   224

	      remove_from_candidate_datatype_list(&search_constant_type_c::lreal_type_name,     symbol->candidate_datatypes);

   225

	      remove_from_candidate_datatype_list(&search_constant_type_c::safelreal_type_name, symbol->candidate_datatypes);

   226

	  }

   227

  }

   228

}

   229

   230

   231

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

   232

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

   233

/*

   234

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

   235

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

   236

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

   237

 */

   238

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

   239

	symbol_c *call_param_value,  *param_datatype;

   240

	identifier_c *param_name;

   241

	function_param_iterator_c       fp_iterator(f_decl);

   242

	function_call_param_iterator_c fcp_iterator(f_call);

   243

	int extensible_parameter_highest_index = -1;

   244

	unsigned int i;

   245

   246

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

   247

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

   248

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

   249

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

   250

		 */

   251

		do {

   252

			param_name = fp_iterator.next();

   253

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

   254

			if(param_name == NULL) return false;

   255

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

   256

   257

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

   258

		/* Get the parameter type */

   259

		param_datatype = base_type(fp_iterator.param_type());

   260

   261

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

   262

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

   263

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

   264

	}

   265

	/* call is compatible! */

   266

	return true;

   267

}

   268

   269

   270

   271

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

   272

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

   273

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

   274

	symbol_c *call_param_value, *call_param_name, *param_datatype;

   275

	symbol_c *verify_duplicate_param;

   276

	identifier_c *param_name;

   277

	function_param_iterator_c       fp_iterator(f_decl);

   278

	function_call_param_iterator_c fcp_iterator(f_call);

   279

	int extensible_parameter_highest_index = -1;

   280

	identifier_c *extensible_parameter_name;

   281

	unsigned int i;

   282

	bool is_first_param = true;

   283

   284

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

   285

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

   286

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

   287

		call_param_value = fcp_iterator.get_current_value();

   288

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

   289

		if (NULL == call_param_value) ERROR;

   290

   291

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

   292

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

   293

   294

		/* Checking if there are duplicated parameter values */

   295

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   296

		if(verify_duplicate_param != call_param_value)

   297

			return false;

   298

   299

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

   300

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

   301

   302

		/* Find the corresponding parameter in function declaration */

   303

		param_name = fp_iterator.search(call_param_name);

   304

		if(param_name == NULL) return false;

   305

		/* Get the parameter data type */

   306

		param_datatype = base_type(fp_iterator.param_type());

   307

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

   308

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

   309

   310

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

   311

		if          (function_call_param_iterator_c::assign_in  == call_param_dir) {

   312

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

   313

			    (function_param_iterator_c::direction_inout != param_dir))

   314

				return false;

   315

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

   316

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

   317

				return false;

   318

		} else ERROR;

   319

   320

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

   321

		if (search_in_candidate_datatype_list(param_datatype, call_param_types) < 0)

   322

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

   323

   324

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

   325

		if (is_first_param)

   326

			if (NULL != first_param_datatype)

   327

				*first_param_datatype = param_datatype;

   328

		is_first_param = false;

   329

	}

   330

	/* call is compatible! */

   331

	return true;

   332

}

   333

   334

   335

   336

   337

/* Handle a generic function call!

   338

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

   339

 * has already had all the candidate_datatype lists filled in!

   340

 *

   341

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

   342

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

   343

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

   344

 */

   345

/*

   346

typedef struct {

   347

  symbol_c *function_name,

   348

  symbol_c *nonformal_operand_list,

   349

  symbol_c *   formal_operand_list,

   350

   351

  std::vector <symbol_c *> &candidate_functions,  

   352

  symbol_c &*called_function_declaration,

   353

  int      &extensible_param_count

   354

} generic_function_call_t;

   355

*/

   356

/*

   357

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

   358

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

   359

                                                       std::vector <symbol_c *> *candidate_datatypes,

   360

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

   361

  */

   362

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

   363

	function_declaration_c *f_decl;

   364

	list_c *parameter_list;

   365

	list_c *parameter_candidate_datatypes;

   366

	symbol_c *returned_parameter_type;

   367

   368

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

   369

   370

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

   371

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

   372

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

   373

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

   374

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

   375

   376

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

   377

	 * to the candidate_datatype list of this function invocation. 

   378

	 *

   379

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

   380

	 * even if the parameters passed to it are invalid.

   381

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

   382

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

   383

	 * spurious error messages.

   384

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

   385

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

   386

	 * compilation is aborted in stage3 (in print_datatypes_error_c).

   387

	 */

   388

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

   389

		f_decl = function_symtable.get_value(lower);

   390

		returned_parameter_type = base_type(f_decl->type_name);

   391

		if (add_datatype_to_candidate_list(fcall, returned_parameter_type))

   392

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

   393

			fcall_data.candidate_functions.push_back(f_decl);

   394

   395

	}

   396

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

   397

		bool compatible = false;

   398

   399

		f_decl = function_symtable.get_value(lower);

   400

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

   401

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

   402

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

   403

		if (compatible) {

   404

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

   405

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

   406

			 */

   407

			returned_parameter_type = base_type(f_decl->type_name);		

   408

			if (add_datatype_to_candidate_list(fcall, returned_parameter_type))

   409

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

   410

				fcall_data.candidate_functions.push_back(f_decl);

   411

		}

   412

	}

   413

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

   414

	return;

   415

}

   416

   417

   418

/* handle implicit FB call in IL.

   419

 * e.g.  CLK ton_var

   420

 *        CU counter_var

   421

 */

   422

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

   423

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

   424

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

   425

	if (NULL == fb_type_id) ERROR;

   426

   427

	function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(fb_type_id);

   428

	if (function_block_type_symtable.end_value() == fb_decl)

   429

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

   430

		 * this is a semantic error.

   431

		 */

   432

		fb_decl = NULL;

   433

   434

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

   435

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

   436

	 * more informative error messages!

   437

	 */

   438

	called_fb_declaration = fb_decl;

   439

   440

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

   441

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

   442

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

   443

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

   444

	 * that are compatible to the FB call. 

   445

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

   446

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

   447

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

   448

	 * correct.

   449

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

   450

	 * here).

   451

	 */

   452

	if (NULL != prev_il_instruction)

   453

		il_instruction->candidate_datatypes = prev_il_instruction->candidate_datatypes; 

   454

   455

	if (debug) std::cout << "handle_implicit_il_fb_call() [" << prev_il_instruction->candidate_datatypes.size() << "] ==> " << il_instruction->candidate_datatypes.size() << " result.\n";

   456

	return NULL;

   457

}

   458

   459

   460

   461

   462

/* handle a binary IL operator, like ADD, SUB, etc... */

   463

void *fill_candidate_datatypes_c::handle_binary_operator(const struct widen_entry widen_table[], symbol_c *symbol, symbol_c *l_expr, symbol_c *r_expr) {

   464

	if (NULL == l_expr) /* if no prev_il_instruction */

   465

		return NULL; 

   466

   467

	for(unsigned int i = 0; i < l_expr->candidate_datatypes.size(); i++)

   468

		for(unsigned int j = 0; j < r_expr->candidate_datatypes.size(); j++)

   469

			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */

   470

			add_datatype_to_candidate_list(symbol, widening_conversion(l_expr->candidate_datatypes[i], r_expr->candidate_datatypes[j], widen_table));

   471

	remove_incompatible_datatypes(symbol);

   472

	if (debug) std::cout <<  "[" << l_expr->candidate_datatypes.size() << "," << r_expr->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";

   473

	return NULL;

   474

}

   475

   476

   477

/* handle a binary ST expression, like '+', '-', etc... */

   478

void *fill_candidate_datatypes_c::handle_binary_expression(const struct widen_entry widen_table[], symbol_c *symbol, symbol_c *l_expr, symbol_c *r_expr) {

   479

	l_expr->accept(*this);

   480

	r_expr->accept(*this);

   481

	return handle_binary_operator(widen_table, symbol, l_expr, r_expr);

   482

}

   483

   484

   485

   486

   487

/* a helper function... */

   488

symbol_c *fill_candidate_datatypes_c::base_type(symbol_c *symbol) {

   489

	/* NOTE: symbol == NULL is valid. It will occur when, for e.g., an undefined/undeclared symbolic_variable is used

   490

	 *       in the code.

   491

	 */

   492

	if (symbol == NULL) return NULL;

   493

	return (symbol_c *)symbol->accept(search_base_type);

   494

}

   495

   496

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

   497

/* B 1.2 - Constants */

   498

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