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

void fill_candidate_datatypes_c::match_nonformal_call(symbol_c *f_call, symbol_c *f_decl, int *error_count) {

    67

	symbol_c *call_param_value,  *param_type;

    68

	identifier_c *param_name;

    69

	function_param_iterator_c       fp_iterator(f_decl);

    70

	function_call_param_iterator_c fcp_iterator(f_call);

    71

	int extensible_parameter_highest_index = -1;

    72

	unsigned int i;

    73

    74

	/* reset error counter */

    75

	if (error_count != NULL) *error_count = 0;

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

		 */

    83

		do {

    84

			param_name = fp_iterator.next();

    85

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

    86

			if(param_name == NULL) {

    87

				(*error_count)++;

    88

				return;

    89

			}

    90

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

    91

    92

		/* Get the parameter type */

    93

		param_type = base_type(fp_iterator.param_type());

    94

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

    95

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

    96

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

    97

				break;

    98

			}

    99

		}

   100

		if (i >= call_param_types.size()) (*error_count)++;

   101

	}

   102

}

   103

   104

void fill_candidate_datatypes_c::match_formal_call(symbol_c *f_call, symbol_c *f_decl, int *error_count) {

   105

	symbol_c *call_param_value, *call_param_name, *param_type;

   106

	symbol_c *verify_duplicate_param;

   107

	identifier_c *param_name;

   108

	function_param_iterator_c       fp_iterator(f_decl);

   109

	function_call_param_iterator_c fcp_iterator(f_call);

   110

	int extensible_parameter_highest_index = -1;

   111

	identifier_c *extensible_parameter_name;

   112

	unsigned int i;

   113

   114

	/* reset error counter */

   115

	if (error_count != NULL) *error_count = 0;

   116

   117

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

   118

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

   119

   120

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

   121

		call_param_value = fcp_iterator.get_current_value();

   122

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

   123

		if (NULL == call_param_value) ERROR;

   124

   125

		/* Checking if there are duplicated parameter values */

   126

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   127

		if(verify_duplicate_param != call_param_value)

   128

			(*error_count)++;

   129

   130

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

   131

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

   132

   133

   134

		/* Find the corresponding parameter in function declaration */

   135

		param_name = fp_iterator.search(call_param_name);

   136

		if(param_name == NULL) {

   137

			(*error_count)++;

   138

		} else {

   139

			/* Get the parameter type */

   140

			param_type = base_type(fp_iterator.param_type());

   141

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

   142

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

   143

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

   144

					break;

   145

			}

   146

			if (i >= call_param_types.size()) (*error_count)++;

   147

		}

   148

	}

   149

   150

}

   151

   152

/* a helper function... */

   153

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

   154

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

   155

	 *       in the code.

   156

	 */

   157

	if (symbol == NULL) return NULL;

   158

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

   159

}

   160

   161

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

   162

/* B 1.2 - Constants */

   163

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

   164

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

   165

/* B 1.2.1 - Numeric Literals */

   166

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

   167

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

   168

	int calc_size;

   169

   170

	calc_size = sizeoftype(symbol);

   171

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

   172

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

   173

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

   174

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

   175

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

   176

	return NULL;

   177

}

   178

   179

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

   180

	int calc_size;

   181

   182

	calc_size = sizeoftype(symbol);

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

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

   193

   194

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

   195

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

   196

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

   197

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

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

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

   206

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

   207

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

   208

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

   209

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

   210

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

   211

	return NULL;

   212

}

   213

   214

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

   215

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

   216

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

   217

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

   218

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

   219

	return NULL;

   220

}

   221

   222

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

   223

	int calc_size;

   224

   225

	calc_size = sizeoftype(symbol);

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

	return NULL;

   236

}

   237

   238

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

   239

	int calc_size;

   240

   241

	calc_size = sizeoftype(symbol);

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

	return NULL;

   271

}

   272

   273

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

   274

	int calc_size;

   275

   276

	calc_size = sizeoftype(symbol);

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

	return NULL;

   306

}

   307

   308

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

   309

	int calc_size;

   310

   311

	calc_size = sizeoftype(symbol);

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

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

   319

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

   320

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

   321

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

   322

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

   337

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

   338

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

   339

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

   340

	return NULL;

   341

}

   342

   343

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

   344

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

   345

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

   346

	return NULL;

   347

}

   348

   349

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

   350

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

   351

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

   352

	return NULL;

   353

}

   354

   355

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

   356

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

   357

	return NULL;

   358

}

   359

   360

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

   361

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

   362

	return NULL;

   363

}

   364

   365

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

   366

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

   367

	return NULL;

   368

}

   369

   370

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

   371

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

   372

	return NULL;

   373

}

   374

   375

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

   376

/* B.1.2.2   Character Strings */

   377

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

   378

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

   379

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

   380

	return NULL;

   381

}

   382

   383

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

   384

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

   385

	return NULL;

   386

}

   387

   388

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

   389

/* B 1.2.3 - Time Literals */

   390

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

   391

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

   392

/* B 1.2.3.1 - Duration */

   393

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

   394

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

   395

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

   396

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

   397

	return NULL;

   398

}

   399

   400

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

   401

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

   402

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

   403

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

   404

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

   405

	return NULL;

   406

}

   407

   408

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

   409

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

   410

	return NULL;

   411

}

   412

   413

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

   414

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

   415

	return NULL;

   416

}

   417

   418

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

   419

/* B 1.3 - Data types */

   420

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

   421

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

   422

/* B 1.3.3 - Derived data types */

   423

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

   424

/*  signed_integer DOTDOT signed_integer */

   425

// SYM_REF2(subrange_c, lower_limit, upper_limit)

   426

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

   427

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

   428

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

   429

   430

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

   431

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

   432

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

   433

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

   434

		}

   435

	}

   436

	return NULL;

   437

}

   438

   439

   440

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

   441

	// TODO !!!

   442

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

   443

	return NULL;

   444

}

   445

   446

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

   447

	symbol_c *enumerated_type;

   448

   449

	if (NULL != symbol->type)

   450

		enumerated_type = symbol->type;

   451

	else {

   452

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

   453

		if (enumerated_type == enumerated_value_symtable.end_value())

   454

			enumerated_type = NULL;

   455

	}

   456

	enumerated_type = base_type(enumerated_type);

   457

	if (NULL != enumerated_type)

   458

		symbol->candidate_datatypes.push_back(enumerated_type);

   459

   460

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

   461

	return NULL;

   462

}

   463

   464

   465

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

   466

/* B 1.4 - Variables */

   467

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

   468

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

   469

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

   470

	if (NULL != result)

   471

		symbol->candidate_datatypes.push_back(result);

   472

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

   473

	return NULL;

   474

}

   475

   476

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

   477

/* B 1.4.1 - Directly Represented Variables */

   478

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

   479

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

   480

	/* Comment added by mario:

   481

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

   482

	 */

   483

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

   484

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

   485

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

   486

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

   487

	 */

   488

	switch (symbol->value[2]) {

   489

	case 'X': // bit - 1 bit

   490

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

   491

		break;

   492

   493

	case 'B': // byte - 8 bits

   494

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

   495

		break;

   496

   497

	case 'W': // word - 16 bits

   498

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

   499

		break;

   500

   501

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

   502

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

   503

		break;

   504

   505

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

   506

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

   507

		break;

   508

   509

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

   510

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

   511

		break;

   512

	}

   513

	return NULL;

   514

}

   515

   516

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

   517

/* B 1.4.2 - Multi-element variables */

   518

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

   519

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

   520

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   521

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

   522

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

   523

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

   524

	 * search_varfb_instance_type->get_basetype_decl(symbol->subscripted_variable)

   525

	 */

   526

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

   527

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

   528

   529

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

   530