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

   163

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

   164

/* B 1.2 - Constants */

   165

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

   166

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

   167

/* B 1.2.1 - Numeric Literals */

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

	}

   175

	return NULL;

   176

}

   177

   178

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

   179

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

   180

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

   181

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

   182

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

   183

	}

   184

	return NULL;

   185

}

   186

   187

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

   188

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

   189

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

   190

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

   191

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

   192

	}

   193

	return NULL;

   194

}

   195

   196

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

   197

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

   198

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

   199

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

   200

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

   201

	}

   202

	return NULL;

   203

}

   204

   205

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

   206

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

   207

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

   208

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

   209

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

   210

	}

   211

	return NULL;

   212

}

   213

   214

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

   215

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

   216

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

   217

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

   218

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

   219

	}

   220

	return NULL;

   221

}

   222

   223

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

   224

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

   225

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

   226

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

   227

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

   228

	}

   229

	return NULL;

   230

}

   231

   232

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

   233

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

   234

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

   235

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

   236

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

   237

	}

   238

	return NULL;

   239

}

   240

   241

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

   242

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

   243

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

   244

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

   245

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

   246

	}

   247

	return NULL;

   248

}

   249

   250

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

   251

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

   252

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

   253

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

   254

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

   255

	}

   256

	return NULL;

   257

}

   258

   259

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

   260

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

   261

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

   262

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

   263

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

   264

	}

   265

	return NULL;

   266

}

   267

   268

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

   269

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

   270

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

   271

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

   272

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

   273

	}

   274

	return NULL;

   275

}

   276

   277

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

   278

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

   279

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

   280

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

   281

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

   282

	}

   283

	return NULL;

   284

}

   285

   286

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

   287

/* B.1.2.2   Character Strings */

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

	}

   295

	return NULL;

   296

}

   297

   298

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

   299

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

   300

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

   301

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

   302

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

   303

	}

   304

	return NULL;

   305

}

   306

   307

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

   308

/* B 1.2.3 - Time Literals */

   309

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

   310

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

   311

/* B 1.2.3.1 - Duration */

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

	}

   319

	return NULL;

   320

}

   321

   322

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

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

	}

   331

	return NULL;

   332

}

   333

   334

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

   335

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

   336

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

   337

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

   338

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

   339

	}

   340

	return NULL;

   341

}

   342

   343

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

   344

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

   345

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

   346

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

   347

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

   348

	}

   349

	return NULL;

   350

}

   351

   352

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

   353

/* B 1.3 - Data types */

   354

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

   355

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

   356

/* B 1.3.3 - Derived data types */

   357

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

   358

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

   359

	// TODO !!!

   360

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

   361

	return NULL;

   362

}

   363

   364

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

   365

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

   366

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

   367

	return NULL;

   368

}

   369

   370

   371

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

   372

/* B 1.4 - Variables */

   373

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

   374

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

   375

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

   376

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

   377

	return NULL;

   378

}

   379

   380

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

   381

/* B 1.4.1 - Directly Represented Variables */

   382

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

   383

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

   384

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

   385

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

   386

	return NULL;

   387

}

   388

   389

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

   390

/* B 1.4.2 - Multi-element variables */

   391

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

   392

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

   393

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   394

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

   395

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

   396

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

   397

   398

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

   399

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

   400

	return NULL;

   401

}

   402

   403

/* subscript_list ',' subscript */

   404

// SYM_LIST(subscript_list_c)

   405

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

   406

#if 0

   407

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

   408

}

   409

#endif

   410

   411

   412

/*  record_variable '.' field_selector */

   413

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

   414

 *           may be accessed as fields of a structured variable!

   415

 *           Code handling a structured_variable_c must take

   416

 *           this into account!

   417

 */

   418

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   419

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

   420

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

   421

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

   422

 */

   423

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

   424

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

   425

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

   426

	return NULL;

   427

}

   428

   429

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

   430

/* B 1.5 Program organization units */

   431

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

   432

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

   433

/* B 1.5.1 Functions */

   434

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

   435

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

   436

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   437

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

   438

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

   439

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

   440

	il_parenthesis_level = 0;

   441

	il_error = false;

   442

	prev_il_instruction = NULL;

   443

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

   444

	prev_il_instruction = NULL;

   445

	delete search_varfb_instance_type;

   446

	search_varfb_instance_type = NULL;

   447

	return NULL;

   448

}

   449

   450

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

   451

/* B 1.5.2 Function blocks */

   452

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

   453

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

   454

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   455

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

   456

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

   457

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

   458

	il_parenthesis_level = 0;

   459

	il_error = false;

   460

	prev_il_instruction = NULL;

   461

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

   462

	prev_il_instruction = NULL;

   463

	delete search_varfb_instance_type;

   464

	search_varfb_instance_type = NULL;

   465

	return NULL;

   466

}

   467

   468

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

   469

/* B 1.5.3 - Programs */

   470

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

   471

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

   472

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   473

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

   474

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

   475

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

   476

	il_parenthesis_level = 0;

   477

	il_error = false;

   478

	prev_il_instruction = NULL;

   479

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

   480

	prev_il_instruction = NULL;

   481

	delete search_varfb_instance_type;

   482

	search_varfb_instance_type = NULL;

   483

	return NULL;

   484

}

   485

   486

   487

   488

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

   489

/* B 1.7 Configuration elements */

   490

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

   491

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

   492

#if 0

   493

	// TODO !!!

   494

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

   495

#endif

   496

	return NULL;

   497

}

   498

   499

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

   500

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

   501

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

   502

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

   503

/* B 2.1 Instructions and Operands */

   504

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

   505

// void *visit(instruction_list_c *symbol);

   506

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

   507

	il_operand = symbol->il_operand;

   508

	if (NULL != symbol->il_operand) {

   509

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

   510

	}

   511

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

   512

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

   513

	il_operand = NULL;

   514

	return NULL;

   515

}

   516