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 <typeinfo>

    41

#include <list>

    42

#include <string>

    43

#include <string.h>

    44

#include <strings.h>

    45

    46

    47

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

    48

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

    49

    50

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

    51

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

    52

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

    53

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

    54

    fprintf(stderr, __VA_ARGS__);                                                      \

    55

    fprintf(stderr, "\n");                                                             \

    56

    il_error = true;                                                                   \

    57

    error_found = true;\

    58

  }

    59

    60

    61

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

    62

static int debug = 0;

    63

    64

print_datatypes_error_c::print_datatypes_error_c(symbol_c *ignore) {

    65

	error_found = false;

    66

}

    67

    68

print_datatypes_error_c::~print_datatypes_error_c(void) {

    69

	error_found = false;

    70

}

    71

    72

int print_datatypes_error_c::get_error_found() {

    73

	return error_found;

    74

}

    75

    76

/* a helper function... */

    77

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

    78

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

    79

	 *       in the code.

    80

	 */

    81

	if (symbol == NULL) return NULL;

    82

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

    83

}

    84

    85

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

    86

/* B 1.2 - Constants */

    87

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

    88

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

    89

/* B 1.2.1 - Numeric Literals */

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

	}

    97

	return NULL;

    98

}

    99

   100

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

   101

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

   102

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

   103

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

   104

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

   105

	}

   106

	return NULL;

   107

}

   108

   109

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

   110

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

   111

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

   112

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

   113

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

   114

	}

   115

	return NULL;

   116

}

   117

   118

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

   119

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

   120

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

   121

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

   122

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

   123

	}

   124

	return NULL;

   125

}

   126

   127

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

   128

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

   129

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

   130

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

   131

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

   132

	}

   133

	return NULL;

   134

}

   135

   136

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

   137

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

   138

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

   139

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

   140

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

   141

	}

   142

	return NULL;

   143

}

   144

   145

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

   146

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

   147

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

   148

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

   149

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

   150

	}

   151

	return NULL;

   152

}

   153

   154

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

   155

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

   156

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

   157

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

   158

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

   159

	}

   160

	return NULL;

   161

}

   162

   163

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

   164

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

   165

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

   166

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

   167

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

   168

	}

   169

	return NULL;

   170

}

   171

   172

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

   173

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

   174

		STAGE3_ERROR(symbol, symbol, "Numerical result exceeds range for ANY_BIT data type.");

   175

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

   176

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

   177

	}

   178

	return NULL;

   179

}

   180

   181

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

   182

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

   183

		STAGE3_ERROR(symbol, symbol, "Numerical result exceeds range for ANY_BOOL data type.");

   184

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

   185

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

   186

	}

   187

	return NULL;

   188

}

   189

   190

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

   191

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

   192

		STAGE3_ERROR(symbol, symbol, "Numerical result exceeds range for ANY_BOOL data type.");

   193

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

   194

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

   195

	}

   196

	return NULL;

   197

}

   198

   199

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

   200

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

   201

		STAGE3_ERROR(symbol, symbol, "Numerical result exceeds range for ANY_BOOL data type.");

   202

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

   203

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

   204

	}

   205

	return NULL;

   206

}

   207

   208

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

   209

/* B.1.2.2   Character Strings */

   210

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

   211

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

   212

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

   213

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

   214

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

   215

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

   216

	}

   217

	return NULL;

   218

}

   219

   220

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

   221

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

   222

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

   223

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

   224

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

   225

	}

   226

	return NULL;

   227

}

   228

   229

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

   230

/* B 1.2.3 - Time Literals */

   231

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

   232

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

   233

/* B 1.2.3.1 - Duration */

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

	}

   241

	return NULL;

   242

}

   243

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

	}

   253

	return NULL;

   254

}

   255

   256

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

   257

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

   258

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

   259

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

   260

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

   261

	}

   262

	return NULL;

   263

}

   264

   265

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

   266

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

   267

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

   268

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

   269

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

   270

	}

   271

	return NULL;

   272

}

   273

   274

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

   275

/* B 1.3 - Data types */

   276

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

   277

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

   278

/* B 1.3.3 - Derived data types */

   279

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

   280

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

   281

	// TODO !!!

   282

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

   283

	return NULL;

   284

}

   285

   286

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

   287

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

   288

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

   289

	return NULL;

   290

}

   291

   292

   293

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

   294

/* B 1.4 - Variables */

   295

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

   296

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

   297

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

   298

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

   299

	return NULL;

   300

}

   301

   302

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

   303

/* B 1.4.1 - Directly Represented Variables */

   304

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

   305

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

   306

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

   307

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

   308

	return NULL;

   309

}

   310

   311

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

   312

/* B 1.4.2 - Multi-element variables */

   313

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

   314

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

   315

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   316

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

   317

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

   318

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

   319

   320

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

   321

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

   322

	return NULL;

   323

}

   324

   325

/* subscript_list ',' subscript */

   326

// SYM_LIST(subscript_list_c)

   327

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

   328

#if 0

   329

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

   330

}

   331

#endif

   332

   333

   334

/*  record_variable '.' field_selector */

   335

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

   336

 *           may be accessed as fields of a structured variable!

   337

 *           Code handling a structured_variable_c must take

   338

 *           this into account!

   339

 */

   340

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   341

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

   342

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

   343

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

   344

 */

   345

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

   346

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

   347

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

   348

	return NULL;

   349

}

   350

   351

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

   352

/* B 1.5 Program organization units */

   353

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

   354

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

   355

/* B 1.5.1 Functions */

   356

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

   357

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

   358

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   359

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

   360

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

   361

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

   362

	il_parenthesis_level = 0;

   363

	il_error = false;

   364

	prev_il_instruction = NULL;

   365

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

   366

	prev_il_instruction = NULL;

   367

	delete search_varfb_instance_type;

   368

	search_varfb_instance_type = NULL;

   369

	return NULL;

   370

}

   371

   372

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

   373

/* B 1.5.2 Function blocks */

   374

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

   375

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

   376

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   377

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

   378

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

   379

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

   380

	il_parenthesis_level = 0;

   381

	il_error = false;

   382

	prev_il_instruction = NULL;

   383

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

   384

	prev_il_instruction = NULL;

   385

	delete search_varfb_instance_type;

   386

	search_varfb_instance_type = NULL;

   387

	return NULL;

   388

}

   389

   390

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

   391

/* B 1.5.3 - Programs */

   392

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

   393

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

   394

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   395

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

   396

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

   397

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

   398

	il_parenthesis_level = 0;

   399

	il_error = false;

   400

	prev_il_instruction = NULL;

   401

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

   402

	prev_il_instruction = NULL;

   403

	delete search_varfb_instance_type;

   404

	search_varfb_instance_type = NULL;

   405

	return NULL;

   406

}

   407

   408

   409

   410

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

   411

/* B 1.7 Configuration elements */

   412

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

   413

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

   414

#if 0

   415

	// TODO !!!

   416

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

   417

#endif

   418

	return NULL;

   419

}

   420

   421

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

   422

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

   423

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

   424

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

   425

/* B 2.1 Instructions and Operands */

   426

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

   427

// void *visit(instruction_list_c *symbol);

   428

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

   429

	il_operand = symbol->il_operand;

   430

	if (NULL != symbol->il_operand) {

   431

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

   432

	}

   433

	/* recursive call to see whether data types are compatible */

   434

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

   435

	il_operand = NULL;

   436

	return NULL;

   437

}

   438

   439

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

   440

	return NULL;

   441

}

   442

   443

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

   444

	return NULL;

   445

}

   446

   447

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

   448

	return NULL;

   449

}

   450

   451

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

   452

	return NULL;

   453

}

   454

   455

   456

/*

   457

    void *visit(il_operand_list_c *symbol);

   458

    void *visit(simple_instr_list_c *symbol);

   459

    void *visit(il_param_list_c *symbol);

   460

    void *visit(il_param_assignment_c *symbol);

   461

    void *visit(il_param_out_assignment_c *symbol);

   462

 */

   463

   464

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

   465

/* B 2.2 Operators */

   466

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

   467

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

   468

	prev_il_instruction = symbol;

   469

	return NULL;

   470

}

   471

   472

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

   473

	if (NULL != symbol->datatype) return NULL;

   474

   475

	il_operand->accept(*this);

   476

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

   477

		(il_operand->candidate_datatypes.size() > 0))

   478

		STAGE3_ERROR(symbol, symbol, "Data type mismatch for 'LDN' operator.");

   479

	prev_il_instruction = symbol;

   480

	return NULL;

   481

}

   482

   483

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

   484

	if (NULL != symbol->datatype) return NULL;

   485

	/* MANU:

   486

	 * if prev_instruction is NULL we can print a message error or warning error like:

   487

	 * we can't use a ST like first instruction.

   488

	 * What do you think?

   489

	 */

   490

	il_operand->accept(*this);

   491

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

   492

		(il_operand->candidate_datatypes.size() > 0))

   493

		STAGE3_ERROR(symbol, symbol, "Data type mismatch for 'ST' operator.");

   494

	prev_il_instruction = symbol;

   495

	return NULL;

   496

}

   497

   498

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

   499

	if (NULL != symbol->datatype) return NULL;

   500

	/* MANU:

   501

	 * if prev_instruction is NULL we can print a message error or warning error like:

   502

	 * we can't use a ST like first instruction.

   503

	 * What do you think?

   504

	 */

   505

	il_operand->accept(*this);

   506

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

   507

		(il_operand->candidate_datatypes.size() > 0))

   508

		STAGE3_ERROR(symbol, symbol, "Data type mismatch for 'STN' operator.");

   509

	prev_il_instruction = symbol;

   510

	return NULL;

   511

}

   512

   513

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

   514

	prev_il_instruction = symbol;

   515

	return NULL;

   516

}

   517

   518

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

   519

	if (NULL != symbol->datatype) return NULL;

   520

   521

	il_operand->accept(*this);

   522

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

   523

		(il_operand->candidate_datatypes.size() > 0))

   524

		STAGE3_ERROR(symbol, symbol, "Data type mismatch for 'S' operator.");

   525

	prev_il_instruction = symbol;

   526

	return NULL;

   527

}

   528

   529

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

   530

	if (NULL != symbol->datatype) return NULL;