1

/*

     2

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

     3

 *

     4

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

     5

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

     6

 *  Copyright (C) 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

 *  Narrow class select and store a data type from candidate data types list for all symbols

    37

 */

    38

    39

#include "narrow_candidate_datatypes.hh"

    40

#include "datatype_functions.hh"

    41

#include <typeinfo>

    42

#include <list>

    43

#include <string>

    44

#include <string.h>

    45

#include <strings.h>

    46

    47

    48

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

    49

static int debug = 0;

    50

    51

narrow_candidate_datatypes_c::narrow_candidate_datatypes_c(symbol_c *ignore) {

    52

}

    53

    54

narrow_candidate_datatypes_c::~narrow_candidate_datatypes_c(void) {

    55

}

    56

    57

bool narrow_candidate_datatypes_c::is_widening_compatible(symbol_c *left_type, symbol_c *right_type, symbol_c *result_type, const struct widen_entry widen_table[]) {

    58

	for (int k = 0; NULL != widen_table[k].left;  k++) {

    59

		if        ((typeid(*left_type)   == typeid(*widen_table[k].left))

    60

		        && (typeid(*right_type)  == typeid(*widen_table[k].right))

    61

				&& (typeid(*result_type) == typeid(*widen_table[k].result))) {

    62

			return true;

    63

		}

    64

	}

    65

	return false;

    66

}

    67

    69

	symbol_c *call_param_value,  *param_type;

    70

	identifier_c *param_name;

    71

	function_param_iterator_c       fp_iterator(f_decl);

    72

	function_call_param_iterator_c fcp_iterator(f_call);

    73

	int extensible_parameter_highest_index = -1;

    74

	unsigned int i;

    75

    77

    78

	/* Iterating through the non-formal parameters of the function call */

    79

	while((call_param_value = fcp_iterator.next_nf()) != NULL) {

    80

		/* Obtaining the type of the value being passed in the function call */

    81

		/* Iterate to the next parameter of the function being called.

    82

		 * Get the name of that parameter, and ignore if EN or ENO.

    83

		 */

    84

		do {

    85

			param_name = fp_iterator.next();

    86

			/* If there is no other parameter declared, then we are passing too many parameters... */

    89

		} while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0));

    90

    92

		call_param_value->datatype = base_type(fp_iterator.param_type());

    93

		call_param_value->accept(*this);

    96

			extensible_parameter_highest_index = fp_iterator.extensible_param_index();

   114

	symbol_c *call_param_value, *call_param_name, *param_type;

   115

	symbol_c *verify_duplicate_param;

   116

	identifier_c *param_name;

   117

	function_param_iterator_c       fp_iterator(f_decl);

   118

	function_call_param_iterator_c fcp_iterator(f_call);

   119

	int extensible_parameter_highest_index = -1;

   120

	identifier_c *extensible_parameter_name;

   121

	unsigned int i;

   122

   124

   125

	/* Iterating through the formal parameters of the function call */

   126

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

   127

   128

		/* Obtaining the value being passed in the function call */

   129

		call_param_value = fcp_iterator.get_current_value();

   130

		/* the following should never occur. If it does, then we have a bug in our code... */

   131

		if (NULL == call_param_value) ERROR;

   132

   133

		/* Find the corresponding parameter in function declaration */

   134

		param_name = fp_iterator.search(call_param_name);

   135

   137

		call_param_name->datatype = base_type(fp_iterator.param_type());

   138

		call_param_name->accept(*this);

   146

	 * of the extensible parameters this particular call uses, in the symbol_c object

   147

	 * of the function call itself!

   148

	 * In calls to non-extensible functions, this value will be set to -1.

   149

	 * This information is later used in stage4 to correctly generate the

   150

	 * output code.

   151

	 */

   157

   158

/* a helper function... */

   159

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

   160

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

   161

	 *       in the code.

   162

	 */

   163

	return NULL;

   164

}

   165

   166

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

   167

/* B 1.2 - Constants */

   168

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

   169

   170

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

   171

/* B 1.3 - Data types */

   172

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

   173

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

   174

/* B 1.3.3 - Derived data types */

   175

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

   176

/*  signed_integer DOTDOT signed_integer */

   177

// SYM_REF2(subrange_c, lower_limit, upper_limit)

   178

void *narrow_candidate_datatypes_c::visit(subrange_c *symbol) {

   179

	symbol->lower_limit->datatype = symbol->datatype;

   180

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

   181

	symbol->upper_limit->datatype = symbol->datatype;

   182

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

   183

	return NULL;

   184

}

   185

   186

   187

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

   188

/* B 1.4 - Variables */

   189

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

   190

   191

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

   192

/* B 1.4.1 - Directly Represented Variables */

   193

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

   194

   195

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

   196

/* B 1.4.2 - Multi-element variables */

   197

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

   198

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

   199

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   200

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

   201

	/* we need to check the data types of the expressions used for the subscripts... */

   202

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

   203

	return NULL;

   204

}

   205

   206

   207

/* subscript_list ',' subscript */

   208

// SYM_LIST(subscript_list_c)

   209

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

   210

	for (int i = 0; i < symbol->n; i++) {

   211

		for (unsigned int k = 0; k < symbol->elements[i]->candidate_datatypes.size(); k++) {

   212

			if (is_ANY_INT_type(symbol->elements[i]->candidate_datatypes[k]))

   213

				symbol->elements[i]->datatype = symbol->elements[i]->candidate_datatypes[k];

   214

		}

   215

		symbol->elements[i]->accept(*this);

   216

	}

   217

	return NULL;  

   218

}

   219

   220

   221

   222

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

   223

/* B 1.5 Program organization units */

   224

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

   225

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

   226

/* B 1.5.1 Functions */

   227

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

   228

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

   229

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   230

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

   231

	prev_il_instruction = NULL;

   232

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

   233

	prev_il_instruction = NULL;

   234

	delete search_varfb_instance_type;

   235

	search_varfb_instance_type = NULL;

   236

	return NULL;

   237

}

   238

   239

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

   240

/* B 1.5.2 Function blocks */

   241

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

   242

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

   243

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   244

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

   245

	prev_il_instruction = NULL;

   246

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

   247

	prev_il_instruction = NULL;

   248

	delete search_varfb_instance_type;

   249

	search_varfb_instance_type = NULL;

   250

	return NULL;

   251

}

   252

   253

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

   254

/* B 1.5.3 Programs */

   255

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

   256

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

   257

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   258

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

   259

	prev_il_instruction = NULL;

   260

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

   261

	prev_il_instruction = NULL;

   262

	delete search_varfb_instance_type;

   263

	search_varfb_instance_type = NULL;

   264

	return NULL;

   265

}

   266

   267

   268

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

   269

/* B 1.7 Configuration elements */

   270

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

   271

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

   272

#if 0

   273

	// TODO !!!

   274

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

   275

#endif

   276

	return NULL;

   277

}

   278

   279

   280

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

   281

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

   282

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

   283

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

   284

/* B 2.1 Instructions and Operands */

   285

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

   286

// void *visit(instruction_list_c *symbol);

   287

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

   288

	il_operand = symbol->il_operand;

   289

	if (NULL != symbol->il_operand) {

   290

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

   291

	}

   292

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

   293

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

   294

	il_operand = NULL;

   295

	return NULL;

   296

}

   297

   298

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

   299

	return NULL;

   300

}

   301

   302

/* MJS: Manuele, could you please not delete the following 2 lines of comments. They help me understand where this class is used

   303

 *     and when it is created by bison - syntax parse, and how it can show up in the abstract syntax tree.

   304

 *

   305

 *       Actually, it could be helpful if we could have all the similar comments already present in visit_expression_type_c

   306

 *       in the 3 new classes fill/narrow/print candidate datatype 

   307

 */

   308

/* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */

   309

// SYM_REF3(il_expression_c, il_expr_operator, il_operand, simple_instr_list);

   310

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

   311

/* MJS: TODO... */

   312

return NULL;

   313

}

   314

   315

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

   316

	return NULL;

   317

}

   318

   319

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

   320

	return NULL;

   321

}

   322

   323

   324

/*

   325

    void *visit(il_operand_list_c *symbol);

   326

    void *visit(simple_instr_list_c *symbol);

   327

    void *visit(il_param_list_c *symbol);

   328

    void *visit(il_param_assignment_c *symbol);

   329

    void *visit(il_param_out_assignment_c *symbol);

   330

 */

   331

   332

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

   333

/* B 2.2 Operators */

   334

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

   335

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

   336

	prev_il_instruction = symbol;

   337

	return NULL;

   338

}

   339

   340

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

   341

	if (symbol->candidate_datatypes.size() != 1)

   342

		return NULL;

   343

	symbol->datatype = symbol->candidate_datatypes[0];

   344

	il_operand->datatype = symbol->datatype;

   345

	il_operand->accept(*this);

   346

	prev_il_instruction = symbol;

   347

	return NULL;

   348

}

   349

   350

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

   351

	if (symbol->candidate_datatypes.size() != 1)

   352

		return NULL;

   353

	symbol->datatype = symbol->candidate_datatypes[0];

   354

	il_operand->datatype = symbol->datatype;

   355

	il_operand->accept(*this);

   356

	prev_il_instruction = symbol;

   357

	return NULL;

   358

}

   359

   360

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

   361

	if (symbol->candidate_datatypes.size() != 1)

   362

		return NULL;

   363

	symbol->datatype = symbol->candidate_datatypes[0];

   364

	il_operand->datatype = symbol->datatype;

   365

	il_operand->accept(*this);

   366

	prev_il_instruction = symbol;

   367

	return NULL;

   368

}

   369

   370

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

   371

	prev_il_instruction = symbol;

   372

	return NULL;

   373

}

   374

   375

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

   376

	if (symbol->candidate_datatypes.size() != 1)

   377

		return NULL;

   378

	symbol->datatype = symbol->candidate_datatypes[0];

   379

	il_operand->datatype = symbol->datatype;

   380

	il_operand->accept(*this);

   381

	prev_il_instruction = symbol;

   382

	return NULL;

   383

}

   384

   385

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

   386

	if (symbol->candidate_datatypes.size() != 1)

   387

		return NULL;

   388

	symbol->datatype = symbol->candidate_datatypes[0];

   389

	il_operand->datatype = symbol->datatype;

   390

	il_operand->accept(*this);

   391

	prev_il_instruction = symbol;

   392

	return NULL;

   393

}

   394

   395

void *narrow_candidate_datatypes_c::visit(S1_operator_c *symbol) {

   396

	if (symbol->candidate_datatypes.size() != 1)

   397

		return NULL;

   398

	symbol->datatype = symbol->candidate_datatypes[0];

   399

	il_operand->datatype = symbol->datatype;

   400

	il_operand->accept(*this);

   401

	prev_il_instruction = symbol;

   402

	return NULL;

   403

}

   404

   405

void *narrow_candidate_datatypes_c::visit(R1_operator_c *symbol) {

   406

	if (symbol->candidate_datatypes.size() != 1)

   407

		return NULL;

   408

	symbol->datatype = symbol->candidate_datatypes[0];

   409

	il_operand->datatype = symbol->datatype;

   410

	il_operand->accept(*this);

   411

	prev_il_instruction = symbol;

   412

	return NULL;

   413

}

   414

   415

void *narrow_candidate_datatypes_c::visit(CLK_operator_c *symbol) {

   416

	prev_il_instruction = symbol;

   417

	return NULL;

   418

}

   419

   420

void *narrow_candidate_datatypes_c::visit(CU_operator_c *symbol) {

   421

	prev_il_instruction = symbol;

   422

	return NULL;

   423

}

   424

   425

void *narrow_candidate_datatypes_c::visit(CD_operator_c *symbol) {

   426

	prev_il_instruction = symbol;

   427

	return NULL;

   428

}

   429

   430

void *narrow_candidate_datatypes_c::visit(PV_operator_c *symbol) {

   431

	prev_il_instruction = symbol;

   432

	return NULL;

   433

}

   434

   435

void *narrow_candidate_datatypes_c::visit(IN_operator_c *symbol) {

   436

	prev_il_instruction = symbol;

   437

	return NULL;

   438

}

   439

   440

void *narrow_candidate_datatypes_c::visit(PT_operator_c *symbol) {

   441

	prev_il_instruction = symbol;

   442

	return NULL;

   443

}

   444

   445

void *narrow_candidate_datatypes_c::visit(AND_operator_c *symbol) {

   446

	if (symbol->candidate_datatypes.size() != 1)

   447

		return NULL;

   448

	symbol->datatype = symbol->candidate_datatypes[0];

   449

	il_operand->datatype = symbol->datatype;

   450

	il_operand->accept(*this);

   451

	prev_il_instruction = symbol;

   452

	return NULL;

   453

}

   454

   455

void *narrow_candidate_datatypes_c::visit(OR_operator_c *symbol) {

   456

	if (symbol->candidate_datatypes.size() != 1)

   457

		return NULL;

   458

	symbol->datatype = symbol->candidate_datatypes[0];

   459

	il_operand->datatype = symbol->datatype;

   460

	il_operand->accept(*this);

   461

	prev_il_instruction = symbol;

   462

	return NULL;

   463

}

   464

   465

void *narrow_candidate_datatypes_c::visit(XOR_operator_c *symbol) {

   466

	if (symbol->candidate_datatypes.size() != 1)

   467

		return NULL;

   468

	symbol->datatype = symbol->candidate_datatypes[0];

   469

	il_operand->datatype = symbol->datatype;

   470

	il_operand->accept(*this);

   471

	prev_il_instruction = symbol;

   472

	return NULL;

   473

}

   474

   475

void *narrow_candidate_datatypes_c::visit(ANDN_operator_c *symbol) {

   476

	if (symbol->candidate_datatypes.size() != 1)

   477

		return NULL;

   478

	symbol->datatype = symbol->candidate_datatypes[0];

   479

	il_operand->datatype = symbol->datatype;

   480

	il_operand->accept(*this);

   481

	prev_il_instruction = symbol;

   482

	return NULL;

   483

}

   484

   485

void *narrow_candidate_datatypes_c::visit(ORN_operator_c *symbol) {

   486

	if (symbol->candidate_datatypes.size() != 1)

   487

		return NULL;

   488

	symbol->datatype = symbol->candidate_datatypes[0];

   489

	il_operand->datatype = symbol->datatype;

   490

	il_operand->accept(*this);

   491

	prev_il_instruction = symbol;

   492

	return NULL;

   493

}

   494

   495

void *narrow_candidate_datatypes_c::visit(XORN_operator_c *symbol) {

   496

	if (symbol->candidate_datatypes.size() != 1)

   497

		return NULL;

   498

	symbol->datatype = symbol->candidate_datatypes[0];

   499

	il_operand->datatype = symbol->datatype;

   500

	il_operand->accept(*this);

   501

	prev_il_instruction = symbol;

   502

	return NULL;

   503

}

   504

   505

void *narrow_candidate_datatypes_c::visit(ADD_operator_c *symbol) {

   506

	prev_il_instruction = symbol;

   507

	return NULL;

   508

}

   509

   510

void *narrow_candidate_datatypes_c::visit(SUB_operator_c *symbol) {

   511

	prev_il_instruction = symbol;

   512

	return NULL;

   513

}

   514

   515

void *narrow_candidate_datatypes_c::visit(MUL_operator_c *symbol) {

   516

	prev_il_instruction = symbol;

   517

	return NULL;

   518

}

   519

   520

void *narrow_candidate_datatypes_c::visit(DIV_operator_c *symbol) {

   521

	prev_il_instruction = symbol;

   522

	return NULL;

   523

}

   524

   525

void *narrow_candidate_datatypes_c::visit(MOD_operator_c *symbol) {

   526