1

/*

     2

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

     3

 *

     4

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

     5

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

     6

 *  Copyright (C) 20011-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 "print_datatypes_error.hh"

    40

#include "datatype_functions.hh"

    41

    42

#include <typeinfo>

    43

#include <list>

    44

#include <string>

    45

#include <string.h>

    46

#include <strings.h>

    47

    48

    49

    50

    51

    52

    53

#define FIRST_(symbol1, symbol2) (((symbol1)->first_order < (symbol2)->first_order)   ? (symbol1) : (symbol2))

    54

#define  LAST_(symbol1, symbol2) (((symbol1)->last_order  > (symbol2)->last_order)    ? (symbol1) : (symbol2))

    55

    56

#define STAGE3_ERROR(error_level, symbol1, symbol2, ...) {                                                                  \

    57

  if (current_display_error_level >= error_level) {                                                                         \

    58

    fprintf(stderr, "%s:%d-%d..%d-%d: error : ",                                                                            \

    59

            FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\

    60

                                                 LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column);\

    61

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    62

    fprintf(stderr, "\n");                                                                                                  \

    63

    il_error = true;                                                                                                        \

    64

    error_found = true;                                                                                                     \

    65

  }                                                                                                                         \

    66

}  

    67

    68

    69

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

    70

static int debug = 0;

    71

    72

print_datatypes_error_c::print_datatypes_error_c(symbol_c *ignore) {

    73

	error_found = false;

    74

	current_display_error_level = error_level_default;

    75

}

    76

    77

print_datatypes_error_c::~print_datatypes_error_c(void) {

    78

}

    79

    80

int print_datatypes_error_c::get_error_found() {

    81

	return error_found;

    82

}

    83

    84

/* a helper function... */

    85

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

    86

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

    87

	 *       in the code.

    88

	 */

    89

	if (symbol == NULL) return NULL;

    90

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

    91

}

    92

    93

    94

    95

    96

/*

    97

typedef struct {

    98

  symbol_c *function_name,

    99

  symbol_c *nonformal_operand_list,

   100

  symbol_c *   formal_operand_list,

   101

   102

  std::vector <symbol_c *> &candidate_functions,  

   103

  symbol_c &*called_function_declaration,

   104

  int      &extensible_param_count

   105

} generic_function_call_t;

   106

*/

   107

void print_datatypes_error_c::handle_function_invocation(symbol_c *fcall, generic_function_call_t fcall_data) {

   108

	symbol_c *param_value, *param_name;

   109

	function_call_param_iterator_c fcp_iterator(fcall);

   110

	bool function_invocation_error = false;

   111

	const char *POU_str = NULL;

   112

   113

	if (generic_function_call_t::POU_FB       == fcall_data.POU_type)  POU_str = "FB";

   114

	if (generic_function_call_t::POU_function == fcall_data.POU_type)  POU_str = "function";

   115

	if (NULL == POU_str) ERROR;

   116

   117

	if ((NULL != fcall_data.formal_operand_list) && (NULL != fcall_data.nonformal_operand_list)) 

   118

		ERROR;

   119

   120

	symbol_c *f_decl = fcall_data.called_function_declaration;

   121

	if ((NULL == f_decl) && (generic_function_call_t::POU_FB ==fcall_data.POU_type)) {

   122

		/* Due to the way the syntax analysis is buit (i.e. stage 2), this should never occur. */

   123

		/* I.e., a FB invocation using an undefined FB variable is not possible in the current implementation of stage 2. */

   124

		ERROR;

   125

	}

   126

	if (NULL == f_decl) {

   127

		STAGE3_ERROR(0, fcall, fcall, "Unable to resolve which overloaded %s '%s' is being invoked.", POU_str, ((identifier_c *)fcall_data.function_name)->value);

   128

		/* we now try to find any function declaration with the same name, just so we can provide some relevant error messages */

   129

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

   130

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

   131

		f_decl = function_symtable.get_value(lower);

   132

	}

   133

   134

	if (NULL != fcall_data.formal_operand_list) {

   135

		fcall_data.formal_operand_list->accept(*this);

   136

		if (NULL != f_decl) {

   137

			function_param_iterator_c fp_iterator(f_decl);

   138

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

   139

				param_value = fcp_iterator.get_current_value();

   140

				/* Find the corresponding parameter in function declaration */

   141

				if (NULL == fp_iterator.search(param_name)) {

   143

				} else if (NULL == param_value->datatype) {

   144

					function_invocation_error = true;

   146

				}

   147

			}

   148

		}

   149

	}

   150

	if (NULL != fcall_data.nonformal_operand_list) {

   151

		fcall_data.nonformal_operand_list->accept(*this);

   152

		if (f_decl)

   153

			for (int i = 1; (param_value = fcp_iterator.next_nf()) != NULL; i++) {

   154

				if (NULL == param_value->datatype) {

   155

					function_invocation_error = true;

   157

				}

   158

			}

   159

	}

   160

   161

	if (function_invocation_error) {

   162

		/* No compatible function exists */

   163

		STAGE3_ERROR(2, fcall, fcall, "Invalid parameters when invoking %s '%s'", POU_str, ((identifier_c *)fcall_data.function_name)->value);

   164

	} 

   165

   166

	return;

   167

}

   168

   169

   170

   171

   172

   173

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

   174

/* B 1.2 - Constants */

   175

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

   176

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

   177

/* B 1.2.1 - Numeric Literals */

   178

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

   179

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

   180

	if (symbol->candidate_datatypes.size() == 0) {

   181

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_REAL data type.");

   182

	} else if (NULL == symbol->datatype) {

   183

		STAGE3_ERROR(4, symbol, symbol, "ANY_REAL data type not valid in this location.");

   184

	}

   185

	return NULL;

   186

}

   187

   188

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

   189

	if (symbol->candidate_datatypes.size() == 0) {

   190

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   191

	} else if (NULL == symbol->datatype) {

   192

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   193

	}

   194

	return NULL;

   195

}

   196

   197

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

   198

	if (symbol->candidate_datatypes.size() == 0) {

   199

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_REAL data type.");

   200

	} else if (NULL == symbol->datatype) {

   201

		STAGE3_ERROR(4, symbol, symbol, "ANY_REAL data type not valid in this location.");

   202

	}

   203

	return NULL;

   204

}

   205

   206

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

   207

	if (symbol->candidate_datatypes.size() == 0) {

   208

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   209

	} else if (NULL == symbol->datatype) {

   210

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   211

	}

   212

	return NULL;

   213

}

   214

   215

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

   216

	if (symbol->candidate_datatypes.size() == 0) {

   217

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   218

	} else if (NULL == symbol->datatype) {

   219

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   220

	}

   221

	return NULL;

   222

}

   223

   224

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

   225

	if (symbol->candidate_datatypes.size() == 0) {

   226

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   227

	} else if (NULL == symbol->datatype) {

   228

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   229

	}

   230

	return NULL;

   231

}

   232

   233

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

   234

	if (symbol->candidate_datatypes.size() == 0) {

   235

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   236

	} else if (NULL == symbol->datatype) {

   237

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   238

	}

   239

	return NULL;

   240

}

   241

   242

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

   243

	if (symbol->candidate_datatypes.size() == 0) {

   244

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for %s data type.", elementary_type_c::to_string(symbol->type));

   245

	} else if (NULL == symbol->datatype) {

   246

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   247

	}

   248

	return NULL;

   249

}

   250

   251

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

   252

	if (symbol->candidate_datatypes.size() == 0) {

   253

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for %s data type.", elementary_type_c::to_string(symbol->type));

   254

	} else if (NULL == symbol->datatype) {

   255

		STAGE3_ERROR(4, symbol, symbol, "ANY_REAL data type not valid in this location.");

   256

	}

   257

	return NULL;

   258

}

   259

   260

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

   261

	if (symbol->candidate_datatypes.size() == 0) {

   262

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for %s data type.", elementary_type_c::to_string(symbol->type));

   263

	} else if (NULL == symbol->datatype) {

   264

		STAGE3_ERROR(4, symbol, symbol, "ANY_BIT data type not valid in this location.");

   265

	}

   266

	return NULL;

   267

}

   268

   269

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

   270

	if (symbol->candidate_datatypes.size() == 0) {

   271

		STAGE3_ERROR(0, symbol, symbol, "Value is not valid for %s data type.", elementary_type_c::to_string(symbol->type));

   272

	} else if (NULL == symbol->datatype) {

   273

		STAGE3_ERROR(4, symbol, symbol, "ANY_BOOL data type not valid in this location.");

   274

	}

   275

	return NULL;

   276

}

   277

   278

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

   279

	if (symbol->candidate_datatypes.size() == 0) {

   280

		STAGE3_ERROR(0, symbol, symbol, "Value is not valid for ANY_BOOL data type.");

   281

	} else if (NULL == symbol->datatype) {

   282

		STAGE3_ERROR(4, symbol, symbol, "ANY_BOOL data type not valid in this location.");

   283

	}

   284

	return NULL;

   285

}

   286

   287

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

   288

	if (symbol->candidate_datatypes.size() == 0) {

   289

		STAGE3_ERROR(0, symbol, symbol, "Value is not valid for ANY_BOOL data type.");

   290

	} else if (NULL == symbol->datatype) {

   291

		STAGE3_ERROR(4, symbol, symbol, "ANY_BOOL data type not valid in this location.");

   292

	}

   293

	return NULL;

   294

}

   295

   296

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

   297

/* B.1.2.2   Character Strings */

   298

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

   299

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

   300

	if (symbol->candidate_datatypes.size() == 0) {

   301

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for WSTRING data type.");

   302

	} else if (NULL == symbol->datatype) {

   303

		STAGE3_ERROR(4, symbol, symbol, "WSTRING data type not valid in this location.");

   304

	}

   305

	return NULL;

   306

}

   307

   308

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

   309

	if (symbol->candidate_datatypes.size() == 0) {

   310

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for STRING data type.");

   311

	} else if (NULL == symbol->datatype) {

   312

		STAGE3_ERROR(4, symbol, symbol, "STRING data type not valid in this location.");

   313

	}

   314

	return NULL;

   315

}

   316

   317

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

   318

/* B 1.2.3 - Time Literals */

   319

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

   320

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

   321

/* B 1.2.3.1 - Duration */

   322

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

   323

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

   324

	if (symbol->candidate_datatypes.size() == 0) {

   325

		STAGE3_ERROR(0, symbol, symbol, "Invalid syntax for TIME data type.");

   326

	} else if (NULL == symbol->datatype) {

   327

		STAGE3_ERROR(4, symbol, symbol, "TIME data type not valid in this location.");

   328

	}

   329

	return NULL;

   330

}

   331

   332

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

   333

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

   334

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

   335

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

   336

	if (symbol->candidate_datatypes.size() == 0) {

   337

		STAGE3_ERROR(0, symbol, symbol, "Invalid syntax for TOD data type.");

   338

	} else if (NULL == symbol->datatype) {

   339

		STAGE3_ERROR(4, symbol, symbol, "TOD data type not valid in this location.");

   340

	}

   341

	return NULL;

   342

}

   343

   344

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

   345

	if (symbol->candidate_datatypes.size() == 0) {

   346

		STAGE3_ERROR(0, symbol, symbol, "Invalid syntax for DATE data type.");

   347

	} else if (NULL == symbol->datatype) {

   348

		STAGE3_ERROR(4, symbol, symbol, "DATE data type not valid in this location.");

   349

	}

   350

	return NULL;

   351

}

   352

   353

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

   354

	if (symbol->candidate_datatypes.size() == 0) {

   355

		STAGE3_ERROR(0, symbol, symbol, "Invalid syntax for DT data type.");

   356

	} else if (NULL == symbol->datatype) {

   357

		STAGE3_ERROR(4, symbol, symbol, "DT data type not valid in this location.");

   358

	}

   359

	return NULL;

   360

}

   361

   362

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

   363

/* B 1.3 - Data types */

   364

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

   365

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

   366

/* B 1.3.3 - Derived data types */

   367

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

   368

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

   369

	// TODO !!!

   370

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

   371

	return NULL;

   372

}

   373

   374

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

   375

	if (symbol->candidate_datatypes.size() == 0)

   376

		STAGE3_ERROR(0, symbol, symbol, "Ambiguous enumerate value or Variable not declared in this scope.");

   377

	return NULL;

   378

}

   379

   380

   381

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

   382

/* B 1.4 - Variables */

   383

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

   384

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

   385

	if (symbol->candidate_datatypes.size() == 0)

   386

		STAGE3_ERROR(0, symbol, symbol, "Variable not declared in this scope.");

   387

	return NULL;

   388

}

   389

   390

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

   391

/* B 1.4.1 - Directly Represented Variables */

   392

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

   393

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

   394

	if (symbol->candidate_datatypes.size() == 0)

   395

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for located variable data type.");

   396

	return NULL;

   397

}

   398

   399

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

   400

/* B 1.4.2 - Multi-element variables */

   401

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

   402

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

   403

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   404

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

   405

	if (symbol->candidate_datatypes.size() == 0)

   406

		STAGE3_ERROR(0, symbol, symbol, "Array variable not declared in this scope.");

   407

   408

	/* recursively call the subscript list to print any errors in the expressions used in the subscript...*/

   409

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

   410

	return NULL;

   411

}

   412

   413

/* subscript_list ',' subscript */

   414

// SYM_LIST(subscript_list_c)

   415

/* NOTE: we inherit from iterator visitor, so we do not need to implement this method... */

   416

#if 0

   417

void *print_datatypes_error_c::visit(subscript_list_c *symbol) {

   418

}

   419

#endif

   420

   421

   422

/*  record_variable '.' field_selector */

   423

/*  WARNING: input and/or output variables of function blocks

   424

 *           may be accessed as fields of a structured variable!

   425

 *           Code handling a structured_variable_c must take

   426

 *           this into account!

   427

 */

   428

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   429

/* NOTE: We do not recursively determine the data types of each field_selector in fill_candidate_datatypes_c,

   430

 * so it does not make sense to recursively visit all the field_selectors to print out error messages. 

   431

 * Maybe in the future, if we find the need to print out more detailed error messages, we might do it that way. For now, we don't!

   432

 */

   433

void *print_datatypes_error_c::visit(structured_variable_c *symbol) {

   434

	if (symbol->candidate_datatypes.size() == 0)

   435

		STAGE3_ERROR(0, symbol, symbol, "Structure variable not declared in this scope.");

   436

	return NULL;

   437

}

   438

   439

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

   440

/* B 1.5 Program organization units */

   441

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

   442

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

   443

/* B 1.5.1 Functions */

   444

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

   445

void *print_datatypes_error_c::visit(function_declaration_c *symbol) {

   446

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   447

	/* We do not check for data type errors in variable declarations, Skip this for now... */

   448

// 	symbol->var_declarations_list->accept(*this);

   449

	if (debug) printf("Print error data types list in body of function %s\n", ((token_c *)(symbol->derived_function_name))->value);

   450

	il_parenthesis_level = 0;

   451

	il_error = false;

   452

	prev_il_instruction = NULL;

   453

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

   454

	prev_il_instruction = NULL;

   455

	delete search_varfb_instance_type;

   456

	search_varfb_instance_type = NULL;

   457

	return NULL;

   458

}

   459

   460

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

   461

/* B 1.5.2 Function blocks */

   462

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

   463

void *print_datatypes_error_c::visit(function_block_declaration_c *symbol) {

   464

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   465

	/* We do not check for data type errors in variable declarations, Skip this for now... */

   466

// 	symbol->var_declarations->accept(*this);

   467

	if (debug) printf("Print error data types list in body of FB %s\n", ((token_c *)(symbol->fblock_name))->value);

   468

	il_parenthesis_level = 0;

   469

	il_error = false;

   470

	prev_il_instruction = NULL;

   471

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

   472

	prev_il_instruction = NULL;

   473

	delete search_varfb_instance_type;

   474

	search_varfb_instance_type = NULL;

   475

	return NULL;

   476

}

   477

   478

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

   479

/* B 1.5.3 - Programs */

   480

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

   481

void *print_datatypes_error_c::visit(program_declaration_c *symbol) {

   482

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   483

	/* We do not check for data type errors in variable declarations, Skip this for now... */

   484

// 	symbol->var_declarations->accept(*this);

   485

	if (debug) printf("Print error data types list in body of program %s\n", ((token_c *)(symbol->program_type_name))->value);

   486

	il_parenthesis_level = 0;

   487

	il_error = false;

   488

	prev_il_instruction = NULL;

   489

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

   490

	prev_il_instruction = NULL;

   491

	delete search_varfb_instance_type;

   492

	search_varfb_instance_type = NULL;

   493

	return NULL;

   494

}

   495

   496

   497

   498

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

   499

/* B 1.7 Configuration elements */

   500

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

   501

void *print_datatypes_error_c::visit(configuration_declaration_c *symbol) {

   502

#if 0

   503

	// TODO !!!

   504

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

   505

#endif

   506

	return NULL;

   507

}

   508

   509

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

   510

/* B.2 - Language IL (Instruction List) */

   511

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

   512

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

   513

/* B 2.1 Instructions and Operands */

   514

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