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

/*

    36

 *  Fill candidate list of data types for all symbols

    37

 */

    38

    39

#include "fill_candidate_datatypes.hh"

    40

#include "datatype_functions.hh"

    41

#include <typeinfo>

    42

#include <list>

    43

#include <string>

    44

#include <string.h>

    45

#include <strings.h>

    46

    47

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

    48

static int debug = 0;

    49

    50

fill_candidate_datatypes_c::fill_candidate_datatypes_c(symbol_c *ignore) {

    51

}

    52

    53

fill_candidate_datatypes_c::~fill_candidate_datatypes_c(void) {

    54

}

    55

    57

	int k;

    58

	/* find a widening table entry compatible */

    59

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

    64

	return NULL;

    65

}

    66

    67

    68

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

    69

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

    70

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

    71

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

    72

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

    73

    return false;

    74

    75

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

    76

  symbol->candidate_datatypes.push_back(datatype);

    77

  return true;

    78

}

    79

    80

    81

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

    82

  add_datatype_to_candidate_list(symbol, datatype1);

    83

  add_datatype_to_candidate_list(symbol, datatype2);

    84

  return true;

    85

}

    86

    87

    88

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

    89

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

    90

/*

    91

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

    92

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

    93

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

    94

 */

    95

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

    96

	symbol_c *call_param_value,  *param_datatype;

    97

	identifier_c *param_name;

    98

	function_param_iterator_c       fp_iterator(f_decl);

    99

	function_call_param_iterator_c fcp_iterator(f_call);

   100

	int extensible_parameter_highest_index = -1;

   101

	unsigned int i;

   102

   103

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

   104

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

   105

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

   106

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

   107

		 */

   108

		do {

   109

			param_name = fp_iterator.next();

   110

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

   111

			if(param_name == NULL) return false;

   112

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

   113

   114

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

   115

		/* Get the parameter type */

   116

		param_datatype = base_type(fp_iterator.param_type());

   117

   118

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

   119

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

   120

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

   121

	}

   122

	/* call is compatible! */

   123

	return true;

   124

}

   125

   126

   127

   128

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

   129

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

   130

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

   131

	symbol_c *call_param_value, *call_param_name, *param_datatype;

   132

	symbol_c *verify_duplicate_param;

   133

	identifier_c *param_name;

   134

	function_param_iterator_c       fp_iterator(f_decl);

   135

	function_call_param_iterator_c fcp_iterator(f_call);

   136

	int extensible_parameter_highest_index = -1;

   137

	identifier_c *extensible_parameter_name;

   138

	unsigned int i;

   139

	bool is_first_param = true;

   140

   141

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

   142

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

   143

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

   144

		call_param_value = fcp_iterator.get_current_value();

   145

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

   146

		if (NULL == call_param_value) ERROR;

   147

   148

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

   149

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

   150

   151

		/* Checking if there are duplicated parameter values */

   152

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   153

		if(verify_duplicate_param != call_param_value)

   154

			return false;

   155

   156

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

   157

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

   158

   159

		/* Find the corresponding parameter in function declaration */

   160

		param_name = fp_iterator.search(call_param_name);

   161

		if(param_name == NULL) return false;

   162

		/* Get the parameter data type */

   163

		param_datatype = base_type(fp_iterator.param_type());

   164

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

   165

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

   166

   167

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

   168

		if          (function_call_param_iterator_c::assign_in  == call_param_dir) {

   169

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

   170

			    (function_param_iterator_c::direction_inout != param_dir))

   171

				return false;

   172

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

   173

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

   174

				return false;

   175

		} else ERROR;

   176

   177

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

   178

		if (search_in_candidate_datatype_list(param_datatype, call_param_types) < 0)

   179

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

   180

   181

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

   182

		if (is_first_param)

   183

			if (NULL != first_param_datatype)

   184

				*first_param_datatype = param_datatype;

   185

		is_first_param = false;

   186

	}

   187

	/* call is compatible! */

   188

	return true;

   189

}

   190

   191

   192

   193

   194

/* Handle a generic function call!

   195

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

   196

 * has already had all the candidate_datatype lists filled in!

   197

 *

   198

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

   199

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

   200

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

   201

 */

   202

/*

   203

typedef struct {

   204

  symbol_c *function_name,

   205

  symbol_c *nonformal_operand_list,

   206

  symbol_c *   formal_operand_list,

   207

   208

  std::vector <symbol_c *> &candidate_functions,  

   209

  symbol_c &*called_function_declaration,

   210

  int      &extensible_param_count

   211

} generic_function_call_t;

   212

*/

   213

/*

   214

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

   215

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

   216

                                                       std::vector <symbol_c *> *candidate_datatypes,

   217

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

   218

  */

   219

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

   220

	function_declaration_c *f_decl;

   221

	list_c *parameter_list;

   222

	list_c *parameter_candidate_datatypes;

   223

	symbol_c *returned_parameter_type;

   224

   225

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

   226

   227

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

   228

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

   229

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

   230

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

   231

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

   232

   233

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

   234

	 * to the candidate_datatype list of this function invocation. 

   235

	 *

   236

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

   237

	 * even if the parameters passed to it are invalid.

   238

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

   239

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

   240

	 * spurious error messages.

   241

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

   242

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

   243

	 * compilation is aborted in stage3 (in print_datatypes_error_c).

   244

	 */

   245

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

   246

		f_decl = function_symtable.get_value(lower);

   247

		returned_parameter_type = base_type(f_decl->type_name);

   248

		if (add_datatype_to_candidate_list(fcall, returned_parameter_type))

   249

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

   250

			fcall_data.candidate_functions.push_back(f_decl);

   251

   252

	}

   253

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

   254

		bool compatible = false;

   255

   256

		f_decl = function_symtable.get_value(lower);

   257

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

   258

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

   259

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

   260

		if (compatible) {

   261

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

   262

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

   263

			 */

   264

			returned_parameter_type = base_type(f_decl->type_name);		

   265

			if (add_datatype_to_candidate_list(fcall, returned_parameter_type))

   266

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

   267

				fcall_data.candidate_functions.push_back(f_decl);

   268

		}

   269

	}

   270

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

   271

	return;

   272

}

   273

   274

   275

/* handle implicit FB call in IL.

   276

 * e.g.  CLK ton_var

   277

 *        CU counter_var

   278

 */

   279

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

   280

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

   281

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

   282

	if (NULL == fb_type_id) ERROR;

   283

   284

	function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(fb_type_id);

   285

	if (function_block_type_symtable.end_value() == fb_decl)

   286

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

   287

		 * this is a semantic error.

   288

		 */

   289

		fb_decl = NULL;

   290

   291

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

   292

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

   293

	 * more informative error messages!

   294

	 */

   295

	called_fb_declaration = fb_decl;

   296

   297

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

   298

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

   299

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

   300

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

   301

	 * that are compatible to the FB call. 

   302

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

   303

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

   304

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

   305

	 * correct.

   306

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

   307

	 * here).

   308

	 */

   309

	if (NULL != prev_il_instruction)

   310

		il_instruction->candidate_datatypes = prev_il_instruction->candidate_datatypes; 

   311

   312

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

   313

}

   314

   315

   316

/* a helper function... */

   317

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

   318

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

   319

	 *       in the code.

   320

	 */

   321

	if (symbol == NULL) return NULL;

   322

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

   323

}

   324

   325

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

   326

/* B 1.2 - Constants */

   327

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

   328

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

   329

/* B 1.2.1 - Numeric Literals */

   330

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

   331

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

   332

   333

void *fill_candidate_datatypes_c::handle_any_integer(symbol_c *symbol) {

   334

	int calc_size;

   335

   336

	calc_size = sizeoftype(symbol);

   337

	if (calc_size <= sizeoftype(&search_constant_type_c::bool_type_name))

   338

	        add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);

   339

	if (calc_size <= sizeoftype(&search_constant_type_c::byte_type_name))

   340

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::byte_type_name, &search_constant_type_c::safebyte_type_name);

   341

	if (calc_size <= sizeoftype(&search_constant_type_c::word_type_name))

   342

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::word_type_name, &search_constant_type_c::safeword_type_name);

   343

	if (calc_size <= sizeoftype(&search_constant_type_c::dword_type_name))

   344

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dword_type_name, &search_constant_type_c::safedword_type_name);

   345

	if (calc_size <= sizeoftype(&search_constant_type_c::lword_type_name))

   346

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lword_type_name, &search_constant_type_c::safelword_type_name);

   347

   348

	if (calc_size < sizeoftype(&search_constant_type_c::sint_type_name))

   349

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::sint_type_name, &search_constant_type_c::safesint_type_name);

   350

	if (calc_size < sizeoftype(&search_constant_type_c::int_type_name))

   351

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::int_type_name, &search_constant_type_c::safeint_type_name);

   352

	if (calc_size < sizeoftype(&search_constant_type_c::dint_type_name))

   353

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dint_type_name, &search_constant_type_c::safedint_type_name);

   354

	if (calc_size < sizeoftype(&search_constant_type_c::lint_type_name))

   355

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lint_type_name, &search_constant_type_c::safelint_type_name);

   356

	if (calc_size <= sizeoftype(&search_constant_type_c::usint_type_name))

   357

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::usint_type_name, &search_constant_type_c::safeusint_type_name);

   358

	if (calc_size <= sizeoftype(&search_constant_type_c::uint_type_name))

   359

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::uint_type_name, &search_constant_type_c::safeuint_type_name);

   360

	if (calc_size <= sizeoftype(&search_constant_type_c::udint_type_name))

   361

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::udint_type_name, &search_constant_type_c::safeudint_type_name);

   362

	if (calc_size <= sizeoftype(&search_constant_type_c::ulint_type_name))

   363

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::ulint_type_name, &search_constant_type_c::safeulint_type_name);

   364

	return NULL;

   365

}

   366

   367

   368

   369

   370

void *fill_candidate_datatypes_c::visit(real_c *symbol) {

   371

	int calc_size;

   372

   373

	calc_size = sizeoftype(symbol);

   374

	if (calc_size <= sizeoftype(&search_constant_type_c::real_type_name))

   375

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::real_type_name,  &search_constant_type_c::safereal_type_name);

   376

	if (calc_size <= sizeoftype(&search_constant_type_c::lreal_type_name))

   377

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lreal_type_name, &search_constant_type_c::safelreal_type_name);

   378

	if (debug) std::cout << "ANY_REAL [" << symbol->candidate_datatypes.size() << "]" << std::endl;

   379

	return NULL;

   380

}

   381

   382

   383

   384

void *fill_candidate_datatypes_c::visit(integer_c *symbol) {

   385

	handle_any_integer(symbol);

   386

	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;

   387

	return NULL;

   388

}

   389

   390

   391

void *fill_candidate_datatypes_c::visit(neg_real_c *symbol) {

   392

	int calc_size;

   393

   394

	calc_size = sizeoftype(symbol);

   395

	if (calc_size <= sizeoftype(&search_constant_type_c::real_type_name))

   396

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::real_type_name, &search_constant_type_c::safereal_type_name);

   397

	if (calc_size <= sizeoftype(&search_constant_type_c::lreal_type_name))

   398

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lreal_type_name, &search_constant_type_c::safelreal_type_name);

   399

	if (debug) std::cout << "neg ANY_REAL [" << symbol->candidate_datatypes.size() << "]" << std::endl;

   400

	return NULL;

   401

}

   402

   403

   404

void *fill_candidate_datatypes_c::visit(neg_integer_c *symbol) {

   405

	int calc_size;

   406

   407

	calc_size = sizeoftype(symbol);

   408

	if (calc_size <= sizeoftype(&search_constant_type_c::int_type_name))

   409

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::int_type_name, &search_constant_type_c::safeint_type_name);

   410

	if (calc_size <= sizeoftype(&search_constant_type_c::sint_type_name))

   411

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::sint_type_name, &search_constant_type_c::safesint_type_name);

   412

	if (calc_size <= sizeoftype(&search_constant_type_c::dint_type_name))

   413

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dint_type_name, &search_constant_type_c::safedint_type_name);

   414

	if (calc_size <= sizeoftype(&search_constant_type_c::lint_type_name))

   415

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lint_type_name, &search_constant_type_c::safelint_type_name);

   416

	if (debug) std::cout << "neg ANY_INT [" << symbol->candidate_datatypes.size() << "]" << std::endl;

   417

	return NULL;

   418

}

   419

   420

   421

void *fill_candidate_datatypes_c::visit(binary_integer_c *symbol) {

   422

	handle_any_integer(symbol);

   423

	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;

   424

	return NULL;

   425

}

   426

   427

   428

   429

void *fill_candidate_datatypes_c::visit(octal_integer_c *symbol) {

   430

	handle_any_integer(symbol);

   431

	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;

   432

	return NULL;

   433

}

   434

   435

   436

   437

void *fill_candidate_datatypes_c::visit(hex_integer_c *symbol) {

   438

	handle_any_integer(symbol);

   439

	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;

   440

	return NULL;

   441

}

   442

   443

   444

// SYM_REF2(integer_literal_c, type, value)

   445

/*

   446

 * integer_literal:

   447

 *   integer_type_name '#' signed_integer

   448

 * | integer_type_name '#' binary_integer

   449

 * | integer_type_name '#' octal_integer

   450

 * | integer_type_name '#' hex_integer

   451

 */

   452

void *fill_candidate_datatypes_c::visit(integer_literal_c *symbol) {

   453

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

   454

	if (search_in_candidate_datatype_list(symbol->type, symbol->value->candidate_datatypes) >= 0)

   455

		add_datatype_to_candidate_list(symbol, symbol->type);

   456

	if (debug) std::cout << "INT_LITERAL [" << symbol->candidate_datatypes.size() << "]\n";

   457

	return NULL;

   458

}

   459

   460

void *fill_candidate_datatypes_c::visit(real_literal_c *symbol) {

   461

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

   462

	if (search_in_candidate_datatype_list(symbol->type, symbol->value->candidate_datatypes) >= 0)

   463

		add_datatype_to_candidate_list(symbol, symbol->type);

   464

	if (debug) std::cout << "REAL_LITERAL [" << symbol->candidate_datatypes.size() << "]\n";

   465

	return NULL;

   466

}

   467

   468

void *fill_candidate_datatypes_c::visit(bit_string_literal_c *symbol) {

   469

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

   470

	if (search_in_candidate_datatype_list(symbol->type, symbol->value->candidate_datatypes) >= 0)

   471

		add_datatype_to_candidate_list(symbol, symbol->type);

   472

	return NULL;

   473

}

   474

   475

void *fill_candidate_datatypes_c::visit(boolean_literal_c *symbol) {

   476

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

   477

 	if (search_in_candidate_datatype_list(symbol->type, symbol->value->candidate_datatypes) >= 0)

   478

		/* if an explicit datat type has been provided (e.g. SAFEBOOL#true), check whether

   479

		 * the possible datatypes of the value is consistent with the desired type.

   480

		 */

   481

		add_datatype_to_candidate_list(symbol, symbol->type);

   482

	else {

   483

		/* Then only a literal TRUE or FALSE was given! */

   484

		/* In this case, symbol->type will be NULL!     */

   485

		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);

   486

	}

   487

	return NULL;

   488

}

   489

   490

void *fill_candidate_datatypes_c::visit(boolean_true_c *symbol) {

   491

	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);

   492

	return NULL;

   493

}

   494

   495

void *fill_candidate_datatypes_c::visit(boolean_false_c *symbol) {

   496

	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);

   497

	return NULL;

   498

}

   499

   500

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