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"

    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

/* B 1.2 - Constants */

    95

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

    96

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

    97

/* B 1.2.1 - Numeric Literals */

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

	}

   105

	return NULL;

   106

}

   107

   108

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

   109

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

   110

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

   111

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

   112

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

   113

	}

   114

	return NULL;

   115

}

   116

   117

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

   118

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

   119

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

   120

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

   121

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

   122

	}

   123

	return NULL;

   124

}

   125

   126

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

   127

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

   128

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

   129

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

   130

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

   131

	}

   132

	return NULL;

   133

}

   134

   135

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

   136

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

   137

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

   138

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

   139

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

   140

	}

   141

	return NULL;

   142

}

   143

   144

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

   145

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

   146

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

   147

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

   148

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

   149

	}

   150

	return NULL;

   151

}

   152

   153

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

   154

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

   155

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

   156

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

   157

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

   158

	}

   159

	return NULL;

   160

}

   161

   162

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

   163

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

   164

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

   165

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

   166

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

   167

	}

   168

	return NULL;

   169

}

   170

   171

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

   172

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

   173

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

   174

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

   175

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

   176

	}

   177

	return NULL;

   178

}

   179

   180

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

   181

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

   182

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

   183

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

   184

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

   185

	}

   186

	return NULL;

   187

}

   188

   189

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

   190

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

   191

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

   192

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

   193

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

   194

	}

   195

	return NULL;

   196

}

   197

   198

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

   199

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

   200

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

   201

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

   202

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

   203

	}

   204

	return NULL;

   205

}

   206

   207

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

   208

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

   209

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

   210

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

   211

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

   212

	}

   213

	return NULL;

   214

}

   215

   216

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

   217

/* B.1.2.2   Character Strings */

   218

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

   219

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

   220

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

   221

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

   222

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

   223

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

   224

	}

   225

	return NULL;

   226

}

   227

   228

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

   229

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

   230

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

   231

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

   232

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

   233

	}

   234

	return NULL;

   235

}

   236

   237

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

   238

/* B 1.2.3 - Time Literals */

   239

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

   240

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

   241

/* B 1.2.3.1 - Duration */

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

	}

   249

	return NULL;

   250

}

   251

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

	}

   261

	return NULL;

   262

}

   263

   264

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

   265

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

   266

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

   267

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

   268

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

   269

	}

   270

	return NULL;

   271

}

   272

   273

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

   274

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

   275

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

   276

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

   277

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

   278

	}

   279

	return NULL;

   280

}

   281

   282

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

   283

/* B 1.3 - Data types */

   284

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

   285

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

   286

/* B 1.3.3 - Derived data types */

   287

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

   288

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

   289

	// TODO !!!

   290

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

   291

	return NULL;

   292

}

   293

   294

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

   295

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

   296

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

   297

	return NULL;

   298

}

   299

   300

   301

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

   302

/* B 1.4 - Variables */

   303

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

   304

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

   305

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

   306

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

   307

	return NULL;

   308

}

   309

   310

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

   311

/* B 1.4.1 - Directly Represented Variables */

   312

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

   313

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

   314

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

   315

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

   316

	return NULL;

   317

}

   318

   319

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

   320

/* B 1.4.2 - Multi-element variables */

   321

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

   322

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

   323

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   324

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

   325

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

   326

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

   327

   328

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

   329

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

   330

	return NULL;

   331

}

   332

   333

/* subscript_list ',' subscript */

   334

// SYM_LIST(subscript_list_c)

   335

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

   336

#if 0

   337

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

   338

}

   339

#endif

   340

   341

   342

/*  record_variable '.' field_selector */

   343

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

   344

 *           may be accessed as fields of a structured variable!

   345

 *           Code handling a structured_variable_c must take

   346

 *           this into account!

   347

 */

   348

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   349

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

   350

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

   351

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

   352

 */

   353

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

   354

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

   355

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

   356

	return NULL;

   357

}

   358

   359

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

   360

/* B 1.5 Program organization units */

   361

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

   362

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

   363

/* B 1.5.1 Functions */

   364

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

   365

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

   366

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   367

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

   368

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

   369

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

   370

	il_parenthesis_level = 0;

   371

	il_error = false;

   372

	prev_il_instruction = NULL;

   373

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

   374

	prev_il_instruction = NULL;

   375

	delete search_varfb_instance_type;

   376

	search_varfb_instance_type = NULL;

   377

	return NULL;

   378

}

   379

   380

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

   381

/* B 1.5.2 Function blocks */

   382

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

   383

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

   384

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   385

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

   386

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

   387

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

   388

	il_parenthesis_level = 0;

   389

	il_error = false;

   390

	prev_il_instruction = NULL;

   391

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

   392

	prev_il_instruction = NULL;

   393

	delete search_varfb_instance_type;

   394

	search_varfb_instance_type = NULL;

   395

	return NULL;

   396

}

   397

   398

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

   399

/* B 1.5.3 - Programs */

   400

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

   401

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

   402

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   403

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

   404

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

   405

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

   406

	il_parenthesis_level = 0;

   407

	il_error = false;

   408

	prev_il_instruction = NULL;

   409

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

   410

	prev_il_instruction = NULL;

   411

	delete search_varfb_instance_type;

   412

	search_varfb_instance_type = NULL;

   413

	return NULL;

   414

}

   415

   416

   417

   418

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

   419

/* B 1.7 Configuration elements */

   420

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

   421

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

   422

#if 0

   423

	// TODO !!!

   424

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

   425

#endif

   426

	return NULL;

   427

}

   428

   429

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

   430

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

   431

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

   432

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

   433

/* B 2.1 Instructions and Operands */

   434

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

   435

// void *visit(instruction_list_c *symbol);

   436

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

   437

	il_operand = symbol->il_operand;

   438

	if (NULL != symbol->il_operand) {

   439

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

   440

	}

   441

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

   442

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

   443

	il_operand = NULL;

   444

	return NULL;

   445

}

   446

   447

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

   448

	return NULL;

   449

}

   450

   451

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

   452

	return NULL;

   453

}

   454

   455

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

   456

	return NULL;

   457

}

   458

   459

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

   460

	return NULL;

   461

}

   462

   463

   464

/*

   465

    void *visit(il_operand_list_c *symbol);

   466

    void *visit(simple_instr_list_c *symbol);

   467

    void *visit(il_param_list_c *symbol);

   468

    void *visit(il_param_assignment_c *symbol);

   469

    void *visit(il_param_out_assignment_c *symbol);

   470

 */

   471

   472

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

   473

/* B 2.2 Operators */

   474

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

   475

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

   476

	prev_il_instruction = symbol;

   477

	return NULL;

   478

}

   479

   480

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

   481

	il_operand->accept(*this);

   482

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

   483

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

   484

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

   485

	prev_il_instruction = symbol;

   486

	return NULL;

   487

}

   488

   489

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

   490

	/* MANU:

   491

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

   492

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

   493

	 * What do you think?

   494

	 */

   495

	il_operand->accept(*this);

   496

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

   497

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

   498

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

   499

	prev_il_instruction = symbol;

   500

	return NULL;

   501

}

   502

   503

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

   504

	/* MANU:

   505

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

   506

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

   507

	 * What do you think?

   508

	 */

   509

	il_operand->accept(*this);

   510

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

   511

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

   512

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

   513

	prev_il_instruction = symbol;

   514

	return NULL;

   515

}

   516

   517

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

   518

	prev_il_instruction = symbol;

   519

	return NULL;

   520

}