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

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

    94

		for(i = 0; i < call_param_value->candidate_datatypes.size(); i++) {

    95

			/* If found (correct data type being passed), then stop the search */

    96

			if(is_type_equal(param_type, call_param_value->candidate_datatypes[i])) break;

    97

		}

    98

		/* if we reached the end of the loop, and no compatible type found, then return false */

    99

		if (i >= call_param_value->candidate_datatypes.size()) return false;

   100

	}

   101

	/* call is compatible! */

   102

	return true;

   103

}

   104

   105

   106

   107

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

   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_type;

   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

   122

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

   123

		call_param_value = fcp_iterator.get_current_value();

   124

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

   125

		if (NULL == call_param_value) ERROR;

   126

   127

		/* Checking if there are duplicated parameter values */

   128

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   129

		if(verify_duplicate_param != call_param_value)

   130

			return false;

   131

   132

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

   133

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

   134

   135

		/* Find the corresponding parameter in function declaration */

   136

		param_name = fp_iterator.search(call_param_name);

   137

		if(param_name == NULL) return false;

   138

		/* Get the parameter type */

   139

		param_type = base_type(fp_iterator.param_type());

   140

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

   141

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

   142

			/* If found (correct data type being passed), then stop the search */

   143

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

   144

		}

   145

		/* if we reached the end of the loop, and no compatible type found, then return false */

   146

		if (i >= call_param_types.size()) return false;

   147

   148

	}

   149

	/* call is compatible! */

   150

	return true;

   151

}

   152

   153

   154

   155

   156

/* a helper function... */

   157

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

   158

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

   159

	 *       in the code.

   160

	 */

   161

	if (symbol == NULL) return NULL;

   162

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

   163

}

   164

   165

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

   166

/* B 1.2 - Constants */

   167

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

   168

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

   169

/* B 1.2.1 - Numeric Literals */

   170

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

   171

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

   172

	int calc_size;

   173

   174

	calc_size = sizeoftype(symbol);

   175

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

   176

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

   177

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

   178

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

   179

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

   180

	return NULL;

   181

}

   182

   183

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

   184

	int calc_size;

   185

   186

	calc_size = sizeoftype(symbol);

   187

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

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

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

   206

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

   207

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

   208

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

   209

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

   210

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

   211

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

   212

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

   213

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

   214

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

   215

	return NULL;

   216

}

   217

   218

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

   219

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

   220

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

   221

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

   222

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

   223

	return NULL;

   224

}

   225

   226

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

   227

	int calc_size;

   228

   229

	calc_size = sizeoftype(symbol);

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

	return NULL;

   240

}

   241

   242

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

   243

	int calc_size;

   244

   245

	calc_size = sizeoftype(symbol);

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

	return NULL;

   275

}

   276

   277

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

   278

	int calc_size;

   279

   280

	calc_size = sizeoftype(symbol);

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

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

   309

	return NULL;

   310

}

   311

   312

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

   313

	int calc_size;

   314

   315

	calc_size = sizeoftype(symbol);

   316

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

   317

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

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

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

   326

   327

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

   328

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

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

   337

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

   338

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

   339

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

   340

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

   341

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

   342

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

   343

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

   344

	return NULL;

   345

}

   346

   347

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

   348

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

   349

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

   350

	return NULL;

   351

}

   352

   353

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

   354

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

   355

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

   356

	return NULL;

   357

}

   358

   359

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

   360

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

   361

	return NULL;

   362

}

   363

   364

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

   365

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

   366

	return NULL;

   367

}

   368

   369

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

   370

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

   371

	return NULL;

   372

}

   373

   374

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

   375

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

   376

	return NULL;

   377

}

   378

   379

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

   380

/* B.1.2.2   Character Strings */

   381

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

   382

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

   383

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

   384

	return NULL;

   385

}

   386

   387

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

   388

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

   389

	return NULL;

   390

}

   391

   392

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

   393

/* B 1.2.3 - Time Literals */

   394

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

   395

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

   396

/* B 1.2.3.1 - Duration */

   397

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

   398

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

   399

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

   400

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

   401

	return NULL;

   402

}

   403

   404

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

   405

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

   406

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

   407

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

   408

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

   409

	return NULL;

   410

}

   411

   412

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

   413

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

   414

	return NULL;

   415

}

   416

   417

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

   418

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

   419

	return NULL;

   420

}

   421

   422

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

   423

/* B 1.3 - Data types */

   424

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

   425

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

   426

/* B 1.3.3 - Derived data types */

   427

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

   428

/*  signed_integer DOTDOT signed_integer */

   429

// SYM_REF2(subrange_c, lower_limit, upper_limit)

   430

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

   431

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

   432

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

   433

   434

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

   435

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

   436

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

   437

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

   438

		}

   439

	}

   440

	return NULL;

   441

}

   442

   443

   444

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

   445

	// TODO !!!

   446

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

   447

	return NULL;

   448

}

   449

   450

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

   451

	symbol_c *enumerated_type;

   452

   453

	if (NULL != symbol->type)

   454

		enumerated_type = symbol->type;

   455

	else {

   456

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

   457

		if (enumerated_type == enumerated_value_symtable.end_value())

   458

			enumerated_type = NULL;

   459

	}

   460

	enumerated_type = base_type(enumerated_type);

   461

	if (NULL != enumerated_type)

   462

		symbol->candidate_datatypes.push_back(enumerated_type);

   463

   464

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

   465

	return NULL;

   466

}

   467

   468

   469

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

   470

/* B 1.4 - Variables */

   471

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

   472

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

   473

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

   474

	if (NULL != result)

   475

		symbol->candidate_datatypes.push_back(result);

   476

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

   477

	return NULL;

   478

}

   479

   480

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

   481

/* B 1.4.1 - Directly Represented Variables */

   482

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

   483

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

   484

	/* Comment added by mario:

   485

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

   486

	 */

   487

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

   488

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

   489

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

   490

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

   491

	 */

   492

	switch (symbol->value[2]) {

   493

	case 'X': // bit - 1 bit

   494

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

   495

		break;

   496

   497

	case 'B': // byte - 8 bits

   498

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

   499

		break;

   500

   501

	case 'W': // word - 16 bits

   502

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

   503

		break;

   504

   505

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

   506

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

   507

		break;

   508

   509

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

   510

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

   511

		break;

   512

   513

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

   514

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

   515

		break;

   516

	}

   517

	return NULL;

   518

}

   519

   520

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

   521

/* B 1.4.2 - Multi-element variables */

   522

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

   523

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

   524

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   525

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