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

    68

	symbol_c *call_param_value,  *param_type;

    69

	identifier_c *param_name;

    70

	function_param_iterator_c       fp_iterator(f_decl);

    71

	function_call_param_iterator_c fcp_iterator(f_call);

    72

	int extensible_parameter_highest_index = -1;

    73

	unsigned int i;

    74

    75

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

    76

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

    77

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

    78

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

    79

		 */

    80

		do {

    81

			param_name = fp_iterator.next();

    82

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

    84

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

    85

    86

		/* Get the parameter type */

    87

		param_type = base_type(fp_iterator.param_type());

   103

	symbol_c *call_param_value, *call_param_name, *param_type;

   104

	symbol_c *verify_duplicate_param;

   105

	identifier_c *param_name;

   106

	function_param_iterator_c       fp_iterator(f_decl);

   107

	function_call_param_iterator_c fcp_iterator(f_call);

   108

	int extensible_parameter_highest_index = -1;

   109

	identifier_c *extensible_parameter_name;

   110

	unsigned int i;

   111

   112

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

   113

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

   114

   115

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

   116

		call_param_value = fcp_iterator.get_current_value();

   117

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

   118

		if (NULL == call_param_value) ERROR;

   119

   120

		/* Checking if there are duplicated parameter values */

   121

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   122

		if(verify_duplicate_param != call_param_value)

   124

   125

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

   126

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

   127

   128

   129

		/* Find the corresponding parameter in function declaration */

   130

		param_name = fp_iterator.search(call_param_name);

   131

		if(param_name == NULL) {

   133

		} else {

   134

			/* Get the parameter type */

   135

			param_type = base_type(fp_iterator.param_type());

   136

			for (i = 0; i < call_param_types.size(); i++) {

   137

				/* If the declared parameter and the parameter from the function call have the same type */

   138

				if(is_type_equal(param_type, call_param_types[i]))

   139

					break;

   140

			}

   146

}

   147

   148

/* a helper function... */

   149

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

   150

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

   151

	 *       in the code.

   152

	 */

   153

	if (symbol == NULL) return NULL;

   154

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

   155

}

   156

   157

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

   158

/* B 1.2 - Constants */

   159

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

   160

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

   161

/* B 1.2.1 - Numeric Literals */

   162

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

   163

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

   164

	int calc_size;

   165

   166

	calc_size = sizeoftype(symbol);

   167

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

   168

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

   169

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

   170

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

   171

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

   172

	return NULL;

   173

}

   174

   175

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

   176

	int calc_size;

   177

   178

	calc_size = sizeoftype(symbol);

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

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

   206

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

   207

	return NULL;

   208

}

   209

   210

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

   211

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

   212

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

   213

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

   214

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

   215

	return NULL;

   216

}

   217

   218

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

   219

	int calc_size;

   220

   221

	calc_size = sizeoftype(symbol);

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

	return NULL;

   232

}

   233

   234

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

   235

	int calc_size;

   236

   237

	calc_size = sizeoftype(symbol);

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

	return NULL;

   267

}

   268

   269

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

   270

	int calc_size;

   271

   272

	calc_size = sizeoftype(symbol);

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

	return NULL;

   302

}

   303

   304

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

   305

	int calc_size;

   306

   307

	calc_size = sizeoftype(symbol);

   308

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

   309

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

   310

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

   311

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

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

	return NULL;

   337

}

   338

   339

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

   340

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

   341

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

   342

	return NULL;

   343

}

   344

   345

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

   346

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

   347

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

   348

	return NULL;

   349

}

   350

   351

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

   352

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

   353

	return NULL;

   354

}

   355

   356

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

   357

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

   358

	return NULL;

   359

}

   360

   361

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

   362

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

   363

	return NULL;

   364

}

   365

   366

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

   367

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

   368

	return NULL;

   369

}

   370

   371

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

   372

/* B.1.2.2   Character Strings */

   373

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

   374

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

   375

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

   376

	return NULL;

   377

}

   378

   379

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

   380

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

   381

	return NULL;

   382

}

   383

   384

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

   385

/* B 1.2.3 - Time Literals */

   386

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

   387

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

   388

/* B 1.2.3.1 - Duration */

   389

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

   390

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

   391

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

   392

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

   393

	return NULL;

   394

}

   395

   396

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

   397

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

   398

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

   399

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

   400

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

   401

	return NULL;

   402

}

   403

   404

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

   405

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

   406

	return NULL;

   407

}

   408

   409

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

   410

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

   411

	return NULL;

   412

}

   413

   414

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

   415

/* B 1.3 - Data types */

   416

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

   417

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

   418

/* B 1.3.3 - Derived data types */

   419

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

   420

/*  signed_integer DOTDOT signed_integer */

   421

// SYM_REF2(subrange_c, lower_limit, upper_limit)

   422

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

   423

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

   424

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

   425

   426

	for (unsigned int u = 0; u < symbol->upper_limit->candidate_datatypes.size(); u++) {

   427

		for(unsigned int l = 0; l < symbol->lower_limit->candidate_datatypes.size(); l++) {

   428

			if (is_type_equal(symbol->upper_limit->candidate_datatypes[u], symbol->lower_limit->candidate_datatypes[l]))

   429

				symbol->candidate_datatypes.push_back(symbol->lower_limit->candidate_datatypes[l]);

   430

		}

   431

	}

   432

	return NULL;

   433

}

   434

   435

   436

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

   437

	// TODO !!!

   438

	/* for the moment we must return NULL so semantic analysis of remaining code is not interrupted! */

   439

	return NULL;

   440

}

   441

   442

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

   443

	symbol_c *enumerated_type;

   444

   445

	if (NULL != symbol->type)

   446

		enumerated_type = symbol->type;

   447

	else {

   448

		enumerated_type = enumerated_value_symtable.find_value(symbol->value);

   449

		if (enumerated_type == enumerated_value_symtable.end_value())

   450

			enumerated_type = NULL;

   451

	}

   452

	enumerated_type = base_type(enumerated_type);

   453

	if (NULL != enumerated_type)

   454

		symbol->candidate_datatypes.push_back(enumerated_type);

   455

   456

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

   457

	return NULL;

   458

}

   459

   460

   461

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

   462

/* B 1.4 - Variables */

   463

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

   464

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

   465

	symbol_c *result = search_varfb_instance_type->get_basetype_decl(symbol);

   466

	if (NULL != result)

   467

		symbol->candidate_datatypes.push_back(result);

   468

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

   469

	return NULL;

   470

}

   471

   472

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

   473

/* B 1.4.1 - Directly Represented Variables */

   474

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

   475

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

   476

	/* Comment added by mario:

   477

	 * The following code is safe, actually, as the lexical parser guarantees the correct IEC61131-3 syntax was used.

   478

	 */

   479

	/* However, we should probably add an assertion in case we later change the lexical parser! */

   480

	/* if (symbol->value == NULL) ERROR;

   481

	 * if (symbol->value[0] == '\0') ERROR;

   482

	 * if (symbol->value[1] == '\0') ERROR;

   483

	 */

   484

	switch (symbol->value[2]) {

   485

	case 'X': // bit - 1 bit

   486

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

   487

		break;

   488

   489

	case 'B': // byte - 8 bits

   490

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

   491

		break;

   492

   493

	case 'W': // word - 16 bits

   494

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

   495

		break;

   496

   497

	case 'D': // double word - 32 bits

   498

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

   499

		break;

   500

   501

	case 'L': // long word - 64 bits

   502

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

   503

		break;

   504

   505

	default:  // if none of the above, then the empty string was used <=> boolean

   506

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

   507

		break;

   508

	}

   509

	return NULL;

   510

}

   511

   512

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

   513

/* B 1.4.2 - Multi-element variables */

   514

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

   515

/*  subscripted_variable '[' subscript_list ']' */

   516

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   517

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

   518

	/* get the declaration of the data type __stored__ in the array... */

   519

	/* if we were to want the data type of the array itself, then we should call_param_name

   520

	 * search_varfb_instance_type->get_basetype_decl(symbol->subscripted_variable)

   521

	 */

   522

	symbol_c *result = search_varfb_instance_type->get_basetype_decl(symbol);

   523

	if (NULL != result) symbol->candidate_datatypes.push_back(result);

   524

   525

	/* recursively call the subscript list, so we can check the data types of the expressions used for the subscripts */

   526

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

   527

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