1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2009-2012  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2012       Manuele Conti (manuele.conti@sirius-es.it)

     6

 *  Copyright (C) 2012       Matteo Facchinetti (matteo.facchinetti@sirius-es.it)

     7

 *

     8

 *  This program is free software: you can redistribute it and/or modify

     9

 *  it under the terms of the GNU General Public License as published by

    10

 *  the Free Software Foundation, either version 3 of the License, or

    11

 *  (at your option) any later version.

    12

 *

    13

 *  This program is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16

 *  GNU General Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License

    19

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    20

 *

    21

 *

    22

 * This code is made available on the understanding that it will not be

    23

 * used in safety-critical situations without a full and competent review.

    24

 */

    25

    26

/*

    27

 * An IEC 61131-3 compiler.

    28

 *

    29

 * Based on the

    30

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    31

 *

    32

 */

    33

    34

    35

/*

    36

 *  Fill candidate list of data types for all symbols

    37

 */

    38

    39

#include "fill_candidate_datatypes.hh"

    40

#include "datatype_functions.hh"

    41

#include <typeinfo>

    42

#include <list>

    43

#include <string>

    44

#include <string.h>

    45

#include <strings.h>

    46

    47

/* set to 1 to see debug info during execution */

    48

static int debug = 0;

    49

    50

fill_candidate_datatypes_c::fill_candidate_datatypes_c(symbol_c *ignore) {

    51

    52

}

    53

    54

fill_candidate_datatypes_c::~fill_candidate_datatypes_c(void) {

    55

}

    56

    57

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

    58

	int k;

    59

	/* find a widening table entry compatible */

    60

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

    61

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

    62

			return widen_table[k].result;

    63

	return NULL;

    64

}

    65

    66

    67

    68

    69

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

    70

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

    71

	symbol_c *call_param_value,  *param_type;

    72

	identifier_c *param_name;

    73

	function_param_iterator_c       fp_iterator(f_decl);

    74

	function_call_param_iterator_c fcp_iterator(f_call);

    75

	int extensible_parameter_highest_index = -1;

    76

	unsigned int i;

    77

    78

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

    79

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

    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) return false;

    87

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

    88

    89

		/* Get the parameter type */

    90

		param_type = base_type(fp_iterator.param_type());

    91

    92

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

    93

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

    94

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

    95

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

    96

		}

    97

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

    98

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

    99

	}

   100

	/* call is compatible! */

   101

	return true;

   102

}

   103

   104

   105

   106

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

   107

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

   108

	symbol_c *call_param_value, *call_param_name, *param_type;

   109

	symbol_c *verify_duplicate_param;

   110

	identifier_c *param_name;

   111

	function_param_iterator_c       fp_iterator(f_decl);

   112

	function_call_param_iterator_c fcp_iterator(f_call);

   113

	int extensible_parameter_highest_index = -1;

   114

	identifier_c *extensible_parameter_name;

   115

	unsigned int i;

   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

			return false;

   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) return false;

   137

		/* Get the parameter type */

   138

		param_type = base_type(fp_iterator.param_type());

   139

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

   140

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

   141

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

   142

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

   143

		}

   144

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

   145

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

   146

   147

	}

   148

	/* call is compatible! */

   149

	return true;

   150

}

   151

   152

   153

   154

   155

/* a helper function... */

   156

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

   157

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

   158

	 *       in the code.

   159

	 */

   160

	if (symbol == NULL) return NULL;

   161

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

   162

}

   163

   164

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

   165

/* B 1.2 - Constants */

   166

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

   167

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

   168

/* B 1.2.1 - Numeric Literals */

   169

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

   170

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

   171

	int calc_size;

   172

   173

	calc_size = sizeoftype(symbol);

   174

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

   175

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

   176

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

   177

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

   178

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

   179

	return NULL;

   180

}

   181

   182

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

   183

	int calc_size;

   184

   185

	calc_size = sizeoftype(symbol);

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

   197

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

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

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

   206

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

   207

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

   208

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

   209

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

   210

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

   211

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

   212

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

   213

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

   214

	return NULL;

   215

}

   216

   217

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

   218

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

   219

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

   220

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

   221

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

   222

	return NULL;

   223

}

   224

   225

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

   226

	int calc_size;

   227

   228

	calc_size = sizeoftype(symbol);

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

	return NULL;

   239

}

   240

   241

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

   242

	int calc_size;

   243

   244

	calc_size = sizeoftype(symbol);

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

	return NULL;

   274

}

   275

   276

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

   277

	int calc_size;

   278

   279

	calc_size = sizeoftype(symbol);

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

	return NULL;

   309

}

   310

   311

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

   312

	int calc_size;

   313

   314

	calc_size = sizeoftype(symbol);

   315

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

   316

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

   317

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

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

   326

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

   327

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

   328

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

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

   337

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

   338

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

   339

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

   340

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

   341

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

   342

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

   343

	return NULL;

   344

}

   345

   346

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

   347

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

   348

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

   349

	return NULL;

   350

}

   351

   352

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

   353

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

   354

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

   355

	return NULL;

   356

}

   357

   358

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

   359

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

   360

	return NULL;

   361

}

   362

   363

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

   364

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

   365

	return NULL;

   366

}

   367

   368

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

   369

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

   370

	return NULL;

   371

}

   372

   373

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

   374

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

   375

	return NULL;

   376

}

   377

   378

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

   379

/* B.1.2.2   Character Strings */

   380

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

   381

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

   382

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

   383

	return NULL;

   384

}

   385

   386

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

   387

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

   388

	return NULL;

   389

}

   390

   391

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

   392

/* B 1.2.3 - Time Literals */

   393

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

   394

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

   395

/* B 1.2.3.1 - Duration */

   396

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

   397

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

   398

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

   399

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

   400

	return NULL;

   401

}

   402

   403

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

   404

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

   405

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

   406

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

   407

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

   408

	return NULL;

   409

}

   410

   411

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

   412

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

   413

	return NULL;

   414

}

   415

   416

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

   417

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

   418

	return NULL;

   419

}

   420

   421

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

   422

/* B 1.3 - Data types */

   423

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

   424

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

   425

/* B 1.3.3 - Derived data types */

   426

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

   427

/*  signed_integer DOTDOT signed_integer */

   428

// SYM_REF2(subrange_c, lower_limit, upper_limit)

   429

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

   430

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

   431

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

   432

   433

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

   434

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

   435

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

   436

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

   437

		}

   438

	}

   439

	return NULL;

   440

}

   441

   442

   443

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

   444

	// TODO !!!

   445

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

   446

	return NULL;

   447

}

   448

   449

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

   450

	symbol_c *enumerated_type;

   451

   452

	if (NULL != symbol->type)

   453

		enumerated_type = symbol->type;

   454

	else {

   455

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

   456

		if (enumerated_type == enumerated_value_symtable.end_value())

   457

			enumerated_type = NULL;

   458

	}

   459

	enumerated_type = base_type(enumerated_type);

   460

	if (NULL != enumerated_type)

   461

		symbol->candidate_datatypes.push_back(enumerated_type);

   462

   463

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

   464

	return NULL;

   465

}

   466

   467

   468

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

   469

/* B 1.4 - Variables */

   470

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

   471

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

   472

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

   473

	if (NULL != result)

   474

		symbol->candidate_datatypes.push_back(result);

   475

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

   476

	return NULL;

   477

}

   478

   479

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

   480

/* B 1.4.1 - Directly Represented Variables */

   481

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

   482

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

   483

	/* Comment added by mario:

   484

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

   485

	 */

   486

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

   487

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

   488

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

   489

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

   490

	 */

   491

	switch (symbol->value[2]) {

   492

	case 'X': // bit - 1 bit

   493

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

   494

		break;

   495

   496

	case 'B': // byte - 8 bits

   497

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

   498

		break;

   499

   500

	case 'W': // word - 16 bits

   501

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

   502

		break;

   503

   504

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

   505

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

   506

		break;

   507

   508

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

   509

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

   510

		break;

   511

   512

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

   513

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

   514

		break;

   515

	}

   516

	return NULL;

   517

}

   518

   519

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

   520

/* B 1.4.2 - Multi-element variables */

   521

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

   522

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

   523

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   524

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

   525

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

   526

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