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

   125

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

   126

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

   127

   139

   140

   141

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

   142

static int debug = 0;

   143

   144

print_datatypes_error_c::print_datatypes_error_c(symbol_c *ignore) {

   145

	error_found = false;

   147

}

   148

   149

print_datatypes_error_c::~print_datatypes_error_c(void) {

   150

}

   151

   152

int print_datatypes_error_c::get_error_found() {

   153

	return error_found;

   154

}

   155

   156

/* a helper function... */

   157

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

   158

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

   159

	 *       in the code.

   160

	 */

   161

	if (symbol == NULL) return NULL;

   162

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

   163

}

   164

   165

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

   166

/* B 1.2 - Constants */

   167

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

   168

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

   169

/* B 1.2.1 - Numeric Literals */

   170

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

   171

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

   172

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

   176

	}

   177

	return NULL;

   178

}

   179

   180

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

   181

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

   185

	}

   186

	return NULL;

   187

}

   188

   189

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

   190

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

   194

	}

   195

	return NULL;

   196

}

   197

   198

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

   199

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

   203

	}

   204

	return NULL;

   205

}

   206

   207

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

   208

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

   212

	}

   213

	return NULL;

   214

}

   215

   216

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

   217

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

   221

	}

   222

	return NULL;

   223

}

   224

   225

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

   226

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

   230

	}

   231

	return NULL;

   232

}

   233

   234

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

   235

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

   239

	}

   240

	return NULL;

   241

}

   242

   243

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

   244

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

   248

	}

   249

	return NULL;

   250

}

   251

   252

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

   253

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

   257

	}

   258

	return NULL;

   259

}

   260

   261

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

   262

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

   266

	}

   267

	return NULL;

   268

}

   269

   270

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

   271

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

   275

	}

   276

	return NULL;

   277

}

   278

   279

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

   280

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

   284

	}

   285

	return NULL;

   286

}

   287

   288

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

   289

/* B.1.2.2   Character Strings */

   290

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

   291

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

   292

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

   296

	}

   297

	return NULL;

   298

}

   299

   300

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

   301

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

   305

	}

   306

	return NULL;

   307

}

   308

   309

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

   310

/* B 1.2.3 - Time Literals */

   311

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

   312

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

   313

/* B 1.2.3.1 - Duration */

   314

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

   315

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

   316

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

   320

	}

   321

	return NULL;

   322

}

   323

   324

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

   325

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

   326

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

   327

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

   328

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

   332

	}

   333

	return NULL;

   334

}

   335

   336

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

   337

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

   341

	}

   342

	return NULL;

   343

}

   344

   345

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

   346

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

   350

	}

   351

	return NULL;

   352

}

   353

   354

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

   355

/* B 1.3 - Data types */

   356

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

   357

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

   358

/* B 1.3.3 - Derived data types */

   359

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

   360

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

   361

	// TODO !!!

   362

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

   363

	return NULL;

   364

}

   365

   366

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

   367

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

   369

	return NULL;

   370

}

   371

   372

   373

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

   374

/* B 1.4 - Variables */

   375

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

   376

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

   377

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

   379

	return NULL;

   380

}

   381

   382

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

   383

/* B 1.4.1 - Directly Represented Variables */

   384

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

   385

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

   386

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

   388

	return NULL;

   389

}

   390

   391

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

   392

/* B 1.4.2 - Multi-element variables */

   393

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

   394

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

   395

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   396

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

   397

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

   399

   400

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

   401

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

   402

	return NULL;

   403

}

   404

   405

/* subscript_list ',' subscript */

   406

// SYM_LIST(subscript_list_c)

   407

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

   408

#if 0

   409

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

   410

}

   411

#endif

   412

   413

   414

/*  record_variable '.' field_selector */

   415

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

   416

 *           may be accessed as fields of a structured variable!

   417

 *           Code handling a structured_variable_c must take

   418

 *           this into account!

   419

 */

   420

// SYM_REF2(structured_variable_c, record_variable, field_selector)

   421

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

   422

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

   423

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

   424

 */

   425

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

   426

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

   428

	return NULL;

   429

}

   430

   431

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

   432

/* B 1.5 Program organization units */

   433

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

   434

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

   435

/* B 1.5.1 Functions */

   436

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

   437

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

   438

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   439

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

   440

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

   441

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

   442

	il_parenthesis_level = 0;

   443

	il_error = false;

   444

	prev_il_instruction = NULL;

   445

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

   446

	prev_il_instruction = NULL;

   447

	delete search_varfb_instance_type;

   448

	search_varfb_instance_type = NULL;

   449

	return NULL;

   450

}

   451

   452

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

   453

/* B 1.5.2 Function blocks */

   454

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

   455

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

   456

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   457

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

   458

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

   459

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

   460

	il_parenthesis_level = 0;

   461

	il_error = false;

   462

	prev_il_instruction = NULL;

   463

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

   464

	prev_il_instruction = NULL;

   465

	delete search_varfb_instance_type;

   466

	search_varfb_instance_type = NULL;

   467

	return NULL;

   468

}

   469

   470

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

   471

/* B 1.5.3 - Programs */

   472

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

   473

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

   474

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   475

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

   476

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

   477

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

   478

	il_parenthesis_level = 0;

   479

	il_error = false;

   480

	prev_il_instruction = NULL;

   481

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

   482

	prev_il_instruction = NULL;

   483

	delete search_varfb_instance_type;

   484

	search_varfb_instance_type = NULL;

   485

	return NULL;

   486

}

   487

   488

   489

   490

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

   491

/* B 1.7 Configuration elements */

   492

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

   493

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

   494

#if 0

   495

	// TODO !!!

   496

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

   497

#endif

   498

	return NULL;

   499

}

   500

   501

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

   502

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

   503

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

   504

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

   505

/* B 2.1 Instructions and Operands */

   506

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

   507

// void *visit(instruction_list_c *symbol);

   508

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

   509

	il_operand = symbol->il_operand;

   510

	if (NULL != symbol->il_operand) {

   511

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

   512

	}

   513

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

   514

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

   515

	il_operand = NULL;

   516

	return NULL;