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

    54

fill_candidate_datatypes_c::~fill_candidate_datatypes_c(void) {

    55

}

    56

    57

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

    58

	int k;

    59

	/* find a widening table entry compatible */

    60

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

    61

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

    62

			return widen_table[k].result;

    63

	return NULL;

    64

}

    65

    66

    67

    68

    69

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

    70

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

    71

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

    72

	symbol_c *call_param_value,  *param_type;

    73

	identifier_c *param_name;

    74

	function_param_iterator_c       fp_iterator(f_decl);

    75

	function_call_param_iterator_c fcp_iterator(f_call);

    76

	int extensible_parameter_highest_index = -1;

    77

	unsigned int i;

    78

    79

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

    80

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

    81

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

    82

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

    83

		 */

    84

		do {

    85

			param_name = fp_iterator.next();

    86

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

    87

			if(param_name == NULL) return false;

    88

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

    89

    90

		/* Get the parameter type */

    91

		param_type = base_type(fp_iterator.param_type());

    92

    93

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

    96

	}

    97

	/* call is compatible! */

    98

	return true;

    99

}

   100

   101

   102

   103

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

   104

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

   105

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

   106

	symbol_c *call_param_value, *call_param_name, *param_type;

   107

	symbol_c *verify_duplicate_param;

   108

	identifier_c *param_name;

   109

	function_param_iterator_c       fp_iterator(f_decl);

   110

	function_call_param_iterator_c fcp_iterator(f_call);

   111

	int extensible_parameter_highest_index = -1;

   112

	identifier_c *extensible_parameter_name;

   113

	unsigned int i;

   114

   115

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

   116

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

   117

   118

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

   119

		call_param_value = fcp_iterator.get_current_value();

   120

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

   121

		if (NULL == call_param_value) ERROR;

   122

   123

		/* Checking if there are duplicated parameter values */

   124

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   125

		if(verify_duplicate_param != call_param_value)

   126

			return false;

   127

   128

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

   129

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

   130

   131

		/* Find the corresponding parameter in function declaration */

   132

		param_name = fp_iterator.search(call_param_name);

   133

		if(param_name == NULL) return false;

   134

		/* Get the parameter type */

   135

		param_type = base_type(fp_iterator.param_type());

   136

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

   139

	}

   140

	/* call is compatible! */

   141

	return true;

   142

}

   143

   144

   145

   146

   147

/* Handle a generic function call!

   148

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

   149

 * has already had all the candidate_datatype lists filled in!

   150

 *

   151

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

   152

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

   153

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

   154

 */

   155

/*

   156

typedef struct {

   157

  symbol_c *function_name,

   158

  symbol_c *nonformal_operand_list,

   159

  symbol_c *   formal_operand_list,

   160

   161

  std::vector <symbol_c *> &candidate_functions,  

   162

  symbol_c &*called_function_declaration,

   163

  int      &extensible_param_count

   164

} generic_function_call_t;

   165

*/

   166

/*

   167

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

   168

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

   169

                                                       std::vector <symbol_c *> *candidate_datatypes,

   170

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

   171

  */

   172

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

   173

	function_declaration_c *f_decl;

   174

	list_c *parameter_list;

   175

	list_c *parameter_candidate_datatypes;

   176

	symbol_c *returned_parameter_type;

   177

   178

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

   179

   180

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

   181

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

   182

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

   183

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

   184

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

   185

   186

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

   187

	 * to the candidate_datatype list of this function invocation. 

   188

	 *

   189

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

   190

	 * even if the parameters passed to it are invalid.

   191

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

   192

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

   193

	 * spurious error messages.

   194

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

   195

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

   196

	 * compilation is aborted in stage3 (in print_datatypes_error_c).

   197

	 */

   198

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

   199

		f_decl = function_symtable.get_value(lower);

   200

		returned_parameter_type = base_type(f_decl->type_name);

   201

		fcall_data.candidate_functions.push_back(f_decl);

   202

		fcall->    candidate_datatypes.push_back(returned_parameter_type);

   203

	}

   204

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

   205

		bool compatible = false;

   206

   207

		f_decl = function_symtable.get_value(lower);

   208

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

   209

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

   210

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

   211

		if (compatible) {

   212

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

   213

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

   214

			 */

   215

			/* TODO

   216

			 * call  int search_in_datatype_list(symbol_c *datatype, std::vector <symbol_c *> candidate_datatypes);

   217

			 * instead of using for loop!

   218

			 */

   219

			unsigned int k;

   220

			returned_parameter_type = base_type(f_decl->type_name);

   221

			for(k = 0; k < fcall->candidate_datatypes.size(); k++) {

   222

				if (is_type_equal(returned_parameter_type, fcall->candidate_datatypes[k]))

   223

					break;

   224

			}

   225

			if (k >= fcall->candidate_datatypes.size()) {

   226

				fcall->    candidate_datatypes.push_back(returned_parameter_type);

   227

				fcall_data.candidate_functions.push_back(f_decl);

   228

			}

   229

		}

   230

	}

   231

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

   232

	return;

   233

}

   234

   235

   236

   237

   238

   239

/* a helper function... */

   240

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

   241

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

   242

	 *       in the code.

   243

	 */

   244

	if (symbol == NULL) return NULL;

   245

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

   246

}

   247

   248

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

   249

/* B 1.2 - Constants */

   250

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

   251

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

   252

/* B 1.2.1 - Numeric Literals */

   253

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

   254

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

   255

	int calc_size;

   256

   257

	calc_size = sizeoftype(symbol);

   258

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

   259

		symbol->candidate_datatypes.push_back(&search_constant_type_c::real_type_name);

   260

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

   261

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lreal_type_name);

   262

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

   263

	return NULL;

   264

}

   265

   266

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

   267

	int calc_size;

   268

   269

	calc_size = sizeoftype(symbol);

   270

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

   271

	        symbol->candidate_datatypes.push_back(&search_constant_type_c::bool_type_name);

   272

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

   273

		symbol->candidate_datatypes.push_back(&search_constant_type_c::byte_type_name);

   274

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

   275

		symbol->candidate_datatypes.push_back(&search_constant_type_c::word_type_name);

   276

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

   277

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dword_type_name);

   278

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

   279

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lword_type_name);

   280

   281

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

   282

		symbol->candidate_datatypes.push_back(&search_constant_type_c::sint_type_name);

   283

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

   284

		symbol->candidate_datatypes.push_back(&search_constant_type_c::int_type_name);

   285

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

   286

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dint_type_name);

   287

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

   288

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lint_type_name);

   289

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

   290

		symbol->candidate_datatypes.push_back(&search_constant_type_c::usint_type_name);

   291

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

   292

		symbol->candidate_datatypes.push_back(&search_constant_type_c::uint_type_name);

   293

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

   294

		symbol->candidate_datatypes.push_back(&search_constant_type_c::udint_type_name);

   295

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

   296

		symbol->candidate_datatypes.push_back(&search_constant_type_c::ulint_type_name);

   297

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

   298

	return NULL;

   299

}

   300

   301

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

   302

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

   303

		symbol->candidate_datatypes.push_back(&search_constant_type_c::real_type_name);

   304

	symbol->candidate_datatypes.push_back(&search_constant_type_c::lreal_type_name);

   305

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

   306

	return NULL;

   307

}

   308

   309

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

   310

	int calc_size;

   311

   312

	calc_size = sizeoftype(symbol);

   313

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

   314

		symbol->candidate_datatypes.push_back(&search_constant_type_c::int_type_name);

   315

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

   316

		symbol->candidate_datatypes.push_back(&search_constant_type_c::sint_type_name);

   317

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

   318

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dint_type_name);

   319

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

   320

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lint_type_name);

   321

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

   322

	return NULL;

   323

}

   324

   325

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

   326

	int calc_size;

   327

   328

	calc_size = sizeoftype(symbol);

   329

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

   330

	        symbol->candidate_datatypes.push_back(&search_constant_type_c::bool_type_name);

   331

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

   332

		symbol->candidate_datatypes.push_back(&search_constant_type_c::byte_type_name);

   333

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

   334

		symbol->candidate_datatypes.push_back(&search_constant_type_c::word_type_name);

   335

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

   336

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dword_type_name);

   337

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

   338

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lword_type_name);

   339

   340

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

   341

		symbol->candidate_datatypes.push_back(&search_constant_type_c::sint_type_name);

   342

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

   343

		symbol->candidate_datatypes.push_back(&search_constant_type_c::int_type_name);

   344

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

   345

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dint_type_name);

   346

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

   347

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lint_type_name);

   348

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

   349

		symbol->candidate_datatypes.push_back(&search_constant_type_c::usint_type_name);

   350

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

   351

		symbol->candidate_datatypes.push_back(&search_constant_type_c::uint_type_name);

   352

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

   353

		symbol->candidate_datatypes.push_back(&search_constant_type_c::udint_type_name);

   354

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

   355

		symbol->candidate_datatypes.push_back(&search_constant_type_c::ulint_type_name);

   356

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

   357

	return NULL;

   358

}

   359

   360

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

   361

	int calc_size;

   362

   363

	calc_size = sizeoftype(symbol);

   364

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

   365

	        symbol->candidate_datatypes.push_back(&search_constant_type_c::bool_type_name);

   366

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

   367

		symbol->candidate_datatypes.push_back(&search_constant_type_c::byte_type_name);

   368

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

   369

		symbol->candidate_datatypes.push_back(&search_constant_type_c::word_type_name);

   370

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

   371

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dword_type_name);

   372

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

   373

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lword_type_name);

   374

   375

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

   376

		symbol->candidate_datatypes.push_back(&search_constant_type_c::sint_type_name);

   377

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

   378

		symbol->candidate_datatypes.push_back(&search_constant_type_c::int_type_name);

   379

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

   380

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dint_type_name);

   381

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

   382

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lint_type_name);

   383

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

   384

		symbol->candidate_datatypes.push_back(&search_constant_type_c::usint_type_name);

   385

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

   386

		symbol->candidate_datatypes.push_back(&search_constant_type_c::uint_type_name);

   387

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

   388

		symbol->candidate_datatypes.push_back(&search_constant_type_c::udint_type_name);

   389

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

   390

		symbol->candidate_datatypes.push_back(&search_constant_type_c::ulint_type_name);

   391

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

   392

	return NULL;

   393

}

   394

   395

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

   396

	int calc_size;

   397

   398

	calc_size = sizeoftype(symbol);

   399

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

   400

	        symbol->candidate_datatypes.push_back(&search_constant_type_c::bool_type_name);

   401

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

   402

		symbol->candidate_datatypes.push_back(&search_constant_type_c::byte_type_name);

   403

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

   404

		symbol->candidate_datatypes.push_back(&search_constant_type_c::word_type_name);

   405

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

   406

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dword_type_name);

   407

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

   408

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lword_type_name);

   409

   410

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

   411

		symbol->candidate_datatypes.push_back(&search_constant_type_c::sint_type_name);

   412

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

   413

		symbol->candidate_datatypes.push_back(&search_constant_type_c::int_type_name);

   414

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

   415

		symbol->candidate_datatypes.push_back(&search_constant_type_c::dint_type_name);

   416

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

   417

		symbol->candidate_datatypes.push_back(&search_constant_type_c::lint_type_name);

   418

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

   419

		symbol->candidate_datatypes.push_back(&search_constant_type_c::usint_type_name);

   420

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

   421

		symbol->candidate_datatypes.push_back(&search_constant_type_c::uint_type_name);

   422

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

   423

		symbol->candidate_datatypes.push_back(&search_constant_type_c::udint_type_name);

   424

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

   425

		symbol->candidate_datatypes.push_back(&search_constant_type_c::ulint_type_name);

   426

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

   427

	return NULL;

   428

}

   429

   430

// SYM_REF2(integer_literal_c, type, value)

   431

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

   432

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

   433

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

   434

		symbol->candidate_datatypes.push_back(symbol->type);

   435

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

   436

	return NULL;

   437

}

   438

   439

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

   440

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

   441

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

   442

		symbol->candidate_datatypes.push_back(symbol->type);

   443

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

   444

	return NULL;

   445

}

   446

   447

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

   448

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

   449

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

   450

		symbol->candidate_datatypes.push_back(symbol->type);

   451

	return NULL;

   452

}

   453

   454

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

   455

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

   456

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

   457

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

   458

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

   459

		 */

   460

		symbol->candidate_datatypes.push_back(symbol->type);

   461

	else {

   462

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

   463

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

   464

		symbol->candidate_datatypes.push_back(&search_constant_type_c::bool_type_name);

   465

		symbol->candidate_datatypes.push_back(&search_constant_type_c::safebool_type_name);

   466

	}

   467

	return NULL;

   468

}

   469

   470

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

   471

	symbol->candidate_datatypes.push_back(&search_constant_type_c::bool_type_name);

   472

	symbol->candidate_datatypes.push_back(&search_constant_type_c::safebool_type_name);

   473

	return NULL;

   474

}

   475

   476

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

   477

	symbol->candidate_datatypes.push_back(&search_constant_type_c::bool_type_name);

   478

	symbol->candidate_datatypes.push_back(&search_constant_type_c::safebool_type_name);

   479

	return NULL;

   480

}

   481

   482

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

   483

/* B.1.2.2   Character Strings */

   484

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

   485

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

   486

	symbol->candidate_datatypes.push_back(&search_constant_type_c::wstring_type_name);

   487

	return NULL;

   488

}

   489

   490

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

   491

	symbol->candidate_datatypes.push_back(&search_constant_type_c::string_type_name);

   492

	return NULL;

   493

}

   494

   495

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

   496

/* B 1.2.3 - Time Literals */

   497

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

   498

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

   499

/* B 1.2.3.1 - Duration */

   500

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

   501

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

   502

	/* TODO: check whether the literal follows the rules specified in section '2.2.3.1 Duration' of the standard! */

   503

	symbol->candidate_datatypes.push_back(symbol->type_name);

   504

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

   505

	return NULL;

   506

}

   507

   508

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

   509

/* B 1.2.3.2 - Time of day and Date */

   510

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

   511

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

   512

	symbol->candidate_datatypes.push_back(symbol->type_name);

   513

	return NULL;

   514

}

   515

   516

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

   517