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

    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

    56

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

    57

	int k;

    58

	/* find a widening table entry compatible */

    59

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

    60

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

    61

			return widen_table[k].result;

    62

	return NULL;

    63

}

    64

    65

    66

    67

    68

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

    69

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

    70

/*

    71

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

    72

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

    73

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

    74

 */

    75

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

    76

	symbol_c *call_param_value,  *param_datatype;

    77

	identifier_c *param_name;

    78

	function_param_iterator_c       fp_iterator(f_decl);

    79

	function_call_param_iterator_c fcp_iterator(f_call);

    80

	int extensible_parameter_highest_index = -1;

    81

	unsigned int i;

    82

    83

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

    84

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

    85

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

    86

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

    87

		 */

    88

		do {

    89

			param_name = fp_iterator.next();

    90

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

    91

			if(param_name == NULL) return false;

    92

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

    93

    94

		/* Get the parameter type */

    95

		param_datatype = base_type(fp_iterator.param_type());

    96

    97

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

    98

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

    99

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

   100

	}

   101

	/* call is compatible! */

   102

	return true;

   103

}

   104

   105

   106

   107

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

   108

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

   109

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

   110

	symbol_c *call_param_value, *call_param_name, *param_datatype;

   111

	symbol_c *verify_duplicate_param;

   112

	identifier_c *param_name;

   113

	function_param_iterator_c       fp_iterator(f_decl);

   114

	function_call_param_iterator_c fcp_iterator(f_call);

   115

	int extensible_parameter_highest_index = -1;

   116

	identifier_c *extensible_parameter_name;

   117

	unsigned int i;

   118

   119

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

   120

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

   121

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

   122

		call_param_value = fcp_iterator.get_current_value();

   123

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

   124

		if (NULL == call_param_value) ERROR;

   125

   126

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

   127

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

   128

   129

		/* Checking if there are duplicated parameter values */

   130

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   131

		if(verify_duplicate_param != call_param_value)

   132

			return false;

   133

   134

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

   135

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

   136

   137

		/* Find the corresponding parameter in function declaration */

   138

		param_name = fp_iterator.search(call_param_name);

   139

		if(param_name == NULL) return false;

   140

		/* Get the parameter data type */

   141

		param_datatype = base_type(fp_iterator.param_type());

   142

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

   143

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

   144

   145

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

   146

		if          (function_call_param_iterator_c::assign_in  == call_param_dir) {

   147

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

   148

			    (function_param_iterator_c::direction_inout != param_dir))

   149

				return false;

   150

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

   151

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

   152

				return false;

   153

		} else ERROR;

   154

   155

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

   156

		if (search_in_candidate_datatype_list(param_datatype, call_param_types) < 0)

   157

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

   158

	}

   159

	/* call is compatible! */

   160

	return true;

   161

}

   162

   163

   164

   165

   166

/* Handle a generic function call!

   167

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

   168

 * has already had all the candidate_datatype lists filled in!

   169

 *

   170

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

   171

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

   172

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

   173

 */

   174

/*

   175

typedef struct {

   176

  symbol_c *function_name,

   177

  symbol_c *nonformal_operand_list,

   178

  symbol_c *   formal_operand_list,

   179

   180

  std::vector <symbol_c *> &candidate_functions,  

   181

  symbol_c &*called_function_declaration,

   182

  int      &extensible_param_count

   183

} generic_function_call_t;

   184

*/

   185

/*

   186

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

   187

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

   188

                                                       std::vector <symbol_c *> *candidate_datatypes,

   189

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

   190

  */

   191

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

   192

	function_declaration_c *f_decl;

   193

	list_c *parameter_list;

   194

	list_c *parameter_candidate_datatypes;

   195

	symbol_c *returned_parameter_type;

   196

   197

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

   198

   199

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

   200

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

   201

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

   202

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

   203

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

   204

   205

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

   206

	 * to the candidate_datatype list of this function invocation. 

   207

	 *

   208

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

   209

	 * even if the parameters passed to it are invalid.

   210

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

   211

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

   212

	 * spurious error messages.

   213

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

   214

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

   215

	 * compilation is aborted in stage3 (in print_datatypes_error_c).

   216

	 */

   217

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

   218

		f_decl = function_symtable.get_value(lower);

   219

		returned_parameter_type = base_type(f_decl->type_name);

   220

		fcall_data.candidate_functions.push_back(f_decl);

   221

		fcall->    candidate_datatypes.push_back(returned_parameter_type);

   222

	}

   223

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

   224

		bool compatible = false;

   225

   226

		f_decl = function_symtable.get_value(lower);

   227

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

   228

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

   229

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

   230

		if (compatible) {

   231

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

   232

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

   233

			 */

   234

			/* TODO

   235

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

   236

			 * instead of using for loop!

   237

			 */

   238

			unsigned int k;

   239

			returned_parameter_type = base_type(f_decl->type_name);

   240

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

   241

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

   242

					break;

   243

			}

   244

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

   245

				fcall->    candidate_datatypes.push_back(returned_parameter_type);

   246

				fcall_data.candidate_functions.push_back(f_decl);

   247

			}

   248

		}

   249

	}

   250

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

   251

	return;

   252

}

   253

   254

   255

/* handle implicit FB call in IL.

   256

 * e.g.  CLK ton_var

   257

 *        CU counter_var

   258

 *

   259

 * The algorithm will be to build a fake il_fb_call_c equivalent to the implicit IL FB call, and let 

   260

 * the visit(il_fb_call_c *) method handle it!

   261

 */

   262

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

   263

	if (NULL == il_operand)

   264

		/* No FB to call was specified. There is nothing we can do... */

   265

		return;

   266

   267

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

   268

	/* This is a call to a non-declared FB/Variable is a semantic error (which is currently caught by stage 2, so this should never occur)

   269

	 * or no operand was given (il_operand == NULL). In this case, we just give up!

   270

	 */

   271

	if (NULL == fb_type_id)

   272

		return;

   273

   274

	function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(fb_type_id);

   275

	if (function_block_type_symtable.end_value() == fb_decl)

   276

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

   277

		 * this is a smeantic error, so there is no way we can evaluate the rest of the code. We simply give up, and leave

   278

		 * the candidate_datatype_list empty, and the called_fb_declaration pointing to NULL

   279

		 */

   280

		return;

   281

   282

	if (NULL == prev_il_instruction) {

   283

		/* This IL implicit FB call (e.g. CLK ton_var) is not preceded by another IL instruction

   284

		 * (or list of instructions) that will set the IL current/default value.

   285

		 * We cannot proceed verifying type compatibility of something that does not ecist.

   286

		 */

   287

		return;

   288

	}

   289

   290

	/* The value being passed to the 'param_name' parameter is actually the prev_il_instruction.

   291

	 * However, we do not place that object directly in the fake il_param_list_c that we will be

   292

	 * creating, since the visit(il_fb_call_c *) method will recursively call every object in that list.

   293

	 * The il_prev_intruction object has already been visited. We DO NOT want to visit it again.

   294

	 * The easiest way to work around this is to simply use a new object, and copy the relevant details to that object!

   295

	 */

   296

	symbol_c param_value = *prev_il_instruction;

   297

   298

	identifier_c variable_name(param_name);

   299

	// SYM_REF1(il_assign_operator_c, variable_name)

   300

	il_assign_operator_c il_assign_operator(&variable_name);  

   301

	// SYM_REF3(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list)

   302

	il_param_assignment_c il_param_assignment(&il_assign_operator, &param_value/*il_operand*/, NULL);

   303

	il_param_list_c il_param_list;

   304

	il_param_list.add_element(&il_param_assignment);

   305

	// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list, symbol_c *called_fb_declaration)

   306

	il_fb_call_c il_fb_call(NULL, il_operand, NULL, &il_param_list);

   307

   308

	il_fb_call.accept(*this);

   309

	copy_candidate_datatype_list(&il_fb_call/*from*/, il_instruction/*to*/);

   310

	called_fb_declaration = il_fb_call.called_fb_declaration;

   311

}

   312

   313

   314

/* a helper function... */

   315

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

   316

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

   317

	 *       in the code.

   318

	 */

   319

	if (symbol == NULL) return NULL;

   320

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

   321

}

   322

   323

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

   324

/* B 1.2 - Constants */

   325

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

   326

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

   327

/* B 1.2.1 - Numeric Literals */

   328

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

   329

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

   330

	int calc_size;

   331

   332

	calc_size = sizeoftype(symbol);

   333

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

   334

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

   335

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

   336

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

   337

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

   338

	return NULL;

   339

}

   340

   341

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

   342

	int calc_size;

   343

   344

	calc_size = sizeoftype(symbol);

   345

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

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

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

   354

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

   355

   356

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

   357

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

   358

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

   359

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

   360

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

   361

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

   362

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

   363

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

   364

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

   365

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

   366

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

   367

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

   368

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

   369

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

   370

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

   371

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

   372

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

   373

	return NULL;

   374

}

   375

   376

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

   377

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

   378

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

   379

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

   380

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

   381

	return NULL;

   382

}

   383

   384

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

   385

	int calc_size;

   386

   387

	calc_size = sizeoftype(symbol);

   388

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

   389

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

   390

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

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

	return NULL;

   398

}

   399

   400

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

   401

	int calc_size;

   402

   403

	calc_size = sizeoftype(symbol);

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

   415

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

   416

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

   417

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

   418

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

   419

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

   420

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

   421

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

   422

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

   423

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

   424

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

   425

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

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

	return NULL;

   433

}

   434

   435

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

   436

	int calc_size;

   437

   438

	calc_size = sizeoftype(symbol);

   439

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

   440

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

   441

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

   442

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

   443

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

   444

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

   445

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

   446

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

   447

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

   448

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

   449

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   456

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

   457

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

   458

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

   459

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

   460

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

   461

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

   462

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

   463

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

   464

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

   465

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

   466

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

   467

	return NULL;

   468

}

   469

   470

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

   471

	int calc_size;

   472

   473

	calc_size = sizeoftype(symbol);

   474

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

   475

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

   476

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

   477

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

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

   485

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

   486

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

   487

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

   488

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

   489

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

   490

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

   491

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

   492

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

   493

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

   494

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

   495

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

   496

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

   497

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

   498

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

   499

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

   500

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

   501

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

   502

	return NULL;

   503

}

   504

   505

// SYM_REF2(integer_literal_c, type, value)

   506

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

   507

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

   508

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

   509

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

   510

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

   511

	return NULL;