1

/*

     2

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

     3

 *

     4

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2012       Manuele Conti (conti.ma@alice.it)

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

 *  This program is distributed in the hope that it will be useful,

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

 *  You should have received a copy of the GNU General Public License

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

 * This code is made available on the understanding that it will not be

    22

 * used in safety-critical situations without a full and competent review.

    23

 */

    24

    25

/*

    26

 * An IEC 61131-3 compiler.

    27

 *

    28

 * Based on the

    29

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    30

 *

    31

 */

    32

    33

    34

/* Determine the value of an ST expression.

    35

 * Filling in all symbols the correct value.

    36

 *

    37

 * For example:

    38

 *       2 + 3         -> returns constant_value_integer = 5

    39

 *       22.2 - 5.0    -> returns constant_value_real    = 17.2

    40

 *       etc...

    41

 */

    42

    43

#include "constant_folding.hh"

    44

#include <typeinfo>

    45

#include <limits>

    46

#include <math.h> /* required for pow function */

    47

#include <stdlib.h> /* required for malloc() */

    48

    49

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

    50

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

    51

    52

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

    53

  if (current_display_error_level >= error_level) {                                                                         \

    54

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

    55

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

    56

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

    57

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    58

    fprintf(stderr, "\n");                                                                                                  \

    59

    error_count++;                                                                                                     \

    60

  }                                                                                                                         \

    61

}

    62

    63

    64

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

    65

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

    66

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

    67

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

    68

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    69

    fprintf(stderr, "\n");                                                                                                  \

    70

    warning_found = true;                                                                                                   \

    71

}

    72

    73

    74

    81

#define DO_OPER(dtype)\

    82

    (NULL != symbol->r_exp->const_value_##dtype ) && \

    83

    (NULL != symbol->l_exp->const_value_##dtype )

    84

    85

    86

#define CHECK_OVERFLOW_SUM(a, b, type)\

    87

	((((std::numeric_limits< type >::max() - a) < (b)) ? 1 : 0) || \

    88

	 (((std::numeric_limits< type >::min() + a) > (b)) ? 1 : 0))

    89

    90

#define CHECK_OVERFLOW_SUB(a, b, type)\

    91

	((((std::numeric_limits< type >::max() - a) < (-b)) ? 1 : 0) || \

    92

	 (((std::numeric_limits< type >::min() + a) > (-b)) ? 1 : 0))

    93

    94

#define SYMBOL_BOOL_VALUE (symbol->exp->const_value_bool)

    95

#define SYMBOL_REAL_VALUE (symbol->exp->const_value_real)

    96

    97

    98

    99

   100

constant_folding_c::constant_folding_c(symbol_c *symbol) {

   101

    error_count = 0;

   102

    current_display_error_level = 0;

   103

}

   104

   106

constant_folding_c::~constant_folding_c(void) {

   107

}

   108

   110

int constant_folding_c::get_error_count() {

   111

	return error_count;

   112

}

   113

   114

   115

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

   116

/* B 1.2 - Constants */

   117

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

   118

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

   119

/* B 1.2.1 - Numeric Literals */

   120

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

   121

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

   128

   129

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

   130

	int64_t *integer_value;

   131

   132

	integer_value = (int64_t *)malloc(sizeof(int64_t));

   133

	*integer_value = extract_integer_value(symbol);

   134

	symbol->const_value_integer = integer_value;

   135

   136

	return NULL;

   137

}

   138

   140

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

   141

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

   142

	if (NULL == symbol->exp->const_value_real)

   143

		ERROR;

   144

	symbol->const_value_real = (double*) malloc(sizeof(double));

   145

	*symbol->const_value_real = - *(symbol->exp->const_value_real);

   146

	return NULL;

   147

}

   148

   150

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

   151

	int64_t *integer_value;

   152

   153

	integer_value = (int64_t *)malloc(sizeof(int64_t));

   154

	*integer_value = extract_integer_value(symbol);

   155

	symbol->const_value_integer = integer_value;

   156

   157

	return NULL;

   158

}

   159

   161

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

   162

   163

	return NULL;

   164

}

   165

   167

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

   168

   169

	return NULL;

   170

}

   171

   173

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

   174

	symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   175

	*(symbol->const_value_integer) = extract_hex_value(symbol);

   176

   177

	return NULL;

   178

}

   179

   181

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

   182

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

   183

	if (NULL == symbol->value->const_value_integer) ERROR;

   184

	symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   185

	*(symbol->const_value_integer) = *(symbol->value->const_value_integer);

   186

   187

	return NULL;

   188

}

   189

   191

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

   192

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

   193

	if (NULL == symbol->value->const_value_real) ERROR;

   194

	symbol->const_value_real = (double*) malloc(sizeof(double));

   195

	*symbol->const_value_real =  *(symbol->value->const_value_real);

   196

   197

	return NULL;

   198

}

   199

   201

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

   202

   203

	return NULL;

   204

}

   205

   207

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

   208

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

   209

	if (NULL == symbol->value->const_value_bool) ERROR;

   210

	symbol->const_value_bool = (bool *)malloc(sizeof(bool));

   211

	*(symbol->const_value_bool) = *(symbol->value->const_value_bool);

   212

   213

	return NULL;

   214

}

   215

   217

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

   218

	symbol->const_value_bool = (bool *)malloc(sizeof(bool));

   219

	*(symbol->const_value_bool) = true;

   220

   221

	return NULL;

   222

}

   223

   225

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

   226

	symbol->const_value_bool = (bool *)malloc(sizeof(bool));

   227

	*(symbol->const_value_bool) = false;

   228

   229

	return NULL;

   230

}

   231

   234

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

   235

/* B.3 - Language ST (Structured Text) */

   236

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

   237

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

   238

/* B 3.1 - Expressions */

   239

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

   240

void *constant_folding_c::visit(or_expression_c *symbol) {

   241

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

   242

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

   243

	if (DO_OPER(bool)) {

   244

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   245

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_bool) || *(symbol->r_exp->const_value_bool);

   246

	}

   247

	if (DO_OPER(integer)) {

   248

		symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   249

		*(symbol->const_value_integer) = *(symbol->l_exp->const_value_integer) | *(symbol->r_exp->const_value_integer);

   250

	}

   251

   252

	return NULL;

   253

}

   254

   256

void *constant_folding_c::visit(xor_expression_c *symbol) {

   257

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

   258

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

   259

	if (DO_OPER(integer)) {

   260

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   261

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_integer) ^ *(symbol->r_exp->const_value_integer);

   262

	}

   263

   264

	return NULL;

   265

}

   266

   268

void *constant_folding_c::visit(and_expression_c *symbol) {

   269

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

   270

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

   271

	if (DO_OPER(bool)) {

   272

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   273

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_bool) && *(symbol->r_exp->const_value_bool);

   274

	}

   275

	if (DO_OPER(integer)) {

   276

		symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   277

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_integer) & *(symbol->r_exp->const_value_integer);

   278

	}

   279

   280

	return NULL;

   281

}

   282

   284

void *constant_folding_c::visit(equ_expression_c *symbol) {

   285

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

   286

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

   287

	if (DO_OPER(bool)) {

   288

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   289

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_bool) == *(symbol->r_exp->const_value_bool);

   290

	}

   291

	if (DO_OPER(integer)) {

   292

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   293

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_integer) == *(symbol->r_exp->const_value_integer);

   294

	}

   295

	if (DO_OPER(real)) {

   296

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   297

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_real) == *(symbol->r_exp->const_value_real);

   298

	}

   299

   300

	return NULL;

   301

}

   302

   304

void *constant_folding_c::visit(notequ_expression_c *symbol) {

   305

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

   306

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

   307

	if (DO_OPER(bool)) {

   308

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   309

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_bool) != *(symbol->r_exp->const_value_bool);

   310

	}

   311

	if (DO_OPER(integer)) {

   312

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   313

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_integer) != *(symbol->r_exp->const_value_integer);

   314

	}

   315

	if (DO_OPER(real)) {

   316

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   317

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_real) != *(symbol->r_exp->const_value_real);

   318

	}

   319

   320

	return NULL;

   321

}

   322

   324

void *constant_folding_c::visit(lt_expression_c *symbol) {

   325

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

   326

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

   327

	if (DO_OPER(integer)) {

   328

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   329

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_integer) < *(symbol->r_exp->const_value_integer);

   330

	}

   331

	if (DO_OPER(real)) {

   332

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   333

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_real) < *(symbol->r_exp->const_value_real);

   334

	}

   335

   336

	return NULL;

   337

}

   338

   340

void *constant_folding_c::visit(gt_expression_c *symbol) {

   341

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

   342

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

   343

	if (DO_OPER(integer)) {

   344

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   345

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_integer) > *(symbol->r_exp->const_value_integer);

   346

	}

   347

	if (DO_OPER(real)) {

   348

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   349

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_real) > *(symbol->r_exp->const_value_real);

   350

	}

   351

   352

	return NULL;

   353

}

   354

   356

void *constant_folding_c::visit(le_expression_c *symbol) {

   357

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

   358

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

   359

	if (DO_OPER(integer)) {

   360

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   361

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_integer) <= *(symbol->r_exp->const_value_integer);

   362

	}

   363

	if (DO_OPER(real)) {

   364

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   365

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_real) <= *(symbol->r_exp->const_value_real);

   366

	}

   367

   368

	return NULL;

   369

}

   370

   372

void *constant_folding_c::visit(ge_expression_c *symbol) {

   373

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

   374

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

   375

	if (DO_OPER(integer)) {

   376

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   377

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_integer) >= *(symbol->r_exp->const_value_integer);

   378

	}

   379

	if (DO_OPER(real)) {

   380

		symbol->const_value_bool = (bool*) malloc(sizeof(bool));

   381

		*(symbol->const_value_bool) = *(symbol->l_exp->const_value_real) >= *(symbol->r_exp->const_value_real);

   382

	}

   383

   384

	return NULL;

   385

}

   386

   388

void *constant_folding_c::visit(add_expression_c *symbol) {

   389

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

   390

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

   391

	if (DO_OPER(integer)) {

   392

		if (CHECK_OVERFLOW_SUM(*(symbol->l_exp->const_value_integer), *(symbol->r_exp->const_value_integer), int64_t))

   393

			STAGE3_ERROR(0, symbol, symbol, "Overflow in constant expression.");

   394

		symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   395

		*(symbol->const_value_integer) = *(symbol->l_exp->const_value_integer) + *(symbol->r_exp->const_value_integer);

   396

	}

   397

	if (DO_OPER(real)) {

   398

		symbol->const_value_real = (double*) malloc(sizeof(double));

   399

		*(symbol->const_value_real) = *(symbol->l_exp->const_value_real) + *(symbol->r_exp->const_value_real);

   400

		/*

   401

		 * According to the IEEE standard, NaN value is used as:

   402

		 *   - representation of a number that has underflowed

   403

		 *   - representation of number that has overflowed

   404

		 *   - number is a higher precision format

   405

		 *   - A complex number

   406

		 */

   407

		 if (isnan(*(symbol->const_value_real)))

   408

			STAGE3_ERROR(0, symbol, symbol, "Overflow in constant expression.");

   409

	}

   410

   411

	return NULL;

   412

}

   413

   415

void *constant_folding_c::visit(sub_expression_c *symbol) {

   416

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

   417

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

   418

	if (DO_OPER(integer)) {

   419

		if (CHECK_OVERFLOW_SUB(*(symbol->l_exp->const_value_integer), *(symbol->r_exp->const_value_integer), int64_t))

   420

			STAGE3_ERROR(0, symbol, symbol, "Overflow in constant expression.");

   421

		symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   422

		*(symbol->const_value_integer) = *(symbol->l_exp->const_value_integer) - *(symbol->r_exp->const_value_integer);

   423

	}

   424

	if (DO_OPER(real)) {

   425

		symbol->const_value_real = (double*) malloc(sizeof(double));

   426

		*(symbol->const_value_real) = *(symbol->l_exp->const_value_real) - *(symbol->r_exp->const_value_real);

   427

		/*

   428

		 * According to the IEEE standard, NaN value is used as:

   429

		 *   - representation of a number that has underflowed

   430

		 *   - representation of number that has overflowed

   431

		 *   - number is a higher precision format

   432

		 *   - A complex number

   433

		 */

   434

		if (isnan(*(symbol->const_value_real)))

   435

			STAGE3_ERROR(0, symbol, symbol, "Overflow in constant expression.");

   436

	}

   437

   438

	return NULL;

   439

}

   440

   442

void *constant_folding_c::visit(mul_expression_c *symbol) {

   443

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

   444

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

   445

	if (DO_OPER(integer)) {

   446

		symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   447

		*(symbol->const_value_integer) = *(symbol->l_exp->const_value_integer) * *(symbol->r_exp->const_value_integer);

   448

	}

   449

	if (DO_OPER(real)) {

   450

		symbol->const_value_real = (double*) malloc(sizeof(double));

   451

		*(symbol->const_value_real) = *(symbol->l_exp->const_value_real) * *(symbol->r_exp->const_value_real);

   452

		/*

   453

		 * According to the IEEE standard, NaN value is used as:

   454

		 *   - representation of a number that has underflowed

   455

		 *   - representation of number that has overflowed

   456

		 *   - number is a higher precision format

   457

		 *   - A complex number

   458

		 */

   459

		if (isnan(*(symbol->const_value_real)))

   460

			STAGE3_ERROR(0, symbol, symbol, "Overflow in constant expression.");

   461

	}

   462

   463

	return NULL;

   464

}

   465

   467

void *constant_folding_c::visit(div_expression_c *symbol) {

   468

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

   469

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

   470

	if (DO_OPER(integer)) {

   471

		if (*(symbol->r_exp->const_value_integer) == 0)

   472

			STAGE3_ERROR(0, symbol, symbol, "Division by zero in constant expression.");

   473

		symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   474

		*(symbol->const_value_integer) = *(symbol->l_exp->const_value_integer) / *(symbol->r_exp->const_value_integer);

   475

	}

   476

	if (DO_OPER(real)) {

   477

		if (*(symbol->r_exp->const_value_real) == 0)

   478

			STAGE3_ERROR(0, symbol, symbol, "Division by zero in constant expression.");

   479

		symbol->const_value_real = (double*) malloc(sizeof(double));

   480

		*(symbol->const_value_real) = *(symbol->l_exp->const_value_real) / *(symbol->r_exp->const_value_real);

   481

		/*

   482

		 * According to the IEEE standard, NaN value is used as:

   483

		 *   - representation of a number that has underflowed

   484

		 *   - representation of number that has overflowed

   485

		 *   - number is a higher precision format

   486

		 *   - A complex number

   487

		 */

   488

		if (isnan(*(symbol->const_value_real)))

   489

			STAGE3_ERROR(0, symbol, symbol, "Overflow in constant expression.");

   490

	}

   491

   492

	return NULL;

   493

}

   494

   496

void *constant_folding_c::visit(mod_expression_c *symbol) {

   497

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

   498

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

   499

	if (DO_OPER(integer)) {

   500

		if (*(symbol->r_exp->const_value_integer) == 0)

   501

			STAGE3_ERROR(0, symbol, symbol, "Division by zero in constant expression.");

   502

		symbol->const_value_integer = (int64_t*) malloc(sizeof(int64_t));

   503

		*(symbol->const_value_integer) = *(symbol->l_exp->const_value_integer) % *(symbol->r_exp->const_value_integer);

   504

   505

	}

   506

   507

	return NULL;

   508

}

   509

   511

void *constant_folding_c::visit(power_expression_c *symbol) {

   512

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

   513

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

   514

	if ((NULL != symbol->l_exp->const_value_real) && (NULL != symbol->r_exp->const_value_integer)) {

   515

		symbol->const_value_real = (double*) malloc(sizeof(double));

   516

		*(symbol->const_value_real) = pow(*(symbol->l_exp->const_value_real), *(symbol->r_exp->const_value_integer));

   517

		/*

   518

		 * According to the IEEE standard, NaN value is used as: