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

    52

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

    53

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

    54

    55

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

    56

  if (current_display_error_level >= error_level) {                                                                         \

    57

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

    58

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

    59

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

    60

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    61

    fprintf(stderr, "\n");                                                                                                  \

    62

    error_count++;                                                                                                     \

    63

  }                                                                                                                         \

    64

}

    65

    66

    67

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

    68

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

    69

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

    70

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

    71

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    72

    fprintf(stderr, "\n");                                                                                                  \

    73

    warning_found = true;                                                                                                   \

    74

}

    75

    76

    77

    78

    79

#define MALLOC(variable, data_type) \

    80

 variable = (data_type *)malloc(sizeof(data_type)); \

    81

 if (variable == NULL) ERROR;

    82

    83

    84

#define DO_OPER(dtype)\

    85

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

    86

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

    87

    88

    89

#define CHECK_OVERFLOW_SUM(a, b, type)\

    90

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

    91

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

    92

    93

#define CHECK_OVERFLOW_SUB(a, b, type)\

    94

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

    95

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

    96

    97

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

    98

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

    99

   100

   101

   102

   103

constant_folding_c::constant_folding_c(symbol_c *symbol) {

   104

    error_count = 0;

   106

    current_display_error_level = 0;

   114

}

   115

   116

   117

constant_folding_c::~constant_folding_c(void) {

   118

}

   119

   120

   121

int constant_folding_c::get_error_count() {

   122

	return error_count;

   123

}

   124

   125

   126

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

   127

/* B 1.2 - Constants */

   128

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

   129

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

   130

/* B 1.2.1 - Numeric Literals */

   131

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

   132

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

   134

	*symbol->const_value_real = extract_real_value(symbol);

   135

   136

	return NULL;

   137

}

   138

   139

   140

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

   141

	int64_t *integer_value;

   142

   143

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

   144

	*integer_value = extract_integer_value(symbol);

   145

	symbol->const_value_integer = integer_value;

   146

   147

	return NULL;

   148

}

   149

   150

   151

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

   152

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

   153

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

   154

		ERROR;

   156

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

   157

	return NULL;

   158

}

   159

   160

   161

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

   162

	int64_t *integer_value;

   163

   164

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

   165

	*integer_value = extract_integer_value(symbol);

   166

	symbol->const_value_integer = integer_value;

   167

   168

	return NULL;

   169

}

   170

   171

   172

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

   173

   174

	return NULL;

   175

}

   176

   177

   178

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

   179

   180

	return NULL;

   181

}

   182

   183

   184

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

   185

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

   186

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

   187

   188

	return NULL;

   189

}

   190

   191

   192

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

   193

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

   194

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

   195

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

   196

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

   197

   198

	return NULL;

   199

}

   200

   201

   202

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

   203

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

   204

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

   206

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

   207

   208

	return NULL;

   209

}

   210

   211

   212

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

   213

   214

	return NULL;

   215

}

   216

   217

   218

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

   219

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

   220

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

   221

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

   222

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

   223

   224

	return NULL;

   225

}

   226

   227

   228

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

   229

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

   230

	*(symbol->const_value_bool) = true;

   231

   232

	return NULL;

   233

}

   234

   235

   236

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

   237

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

   238

	*(symbol->const_value_bool) = false;

   239

   240

	return NULL;

   241

}

   242

   243

   244

   245

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

   246

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

   247

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

   248

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

   249

/* B 3.1 - Expressions */

   250

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

   251

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

   252

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

   253

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

   254

	if (DO_OPER(bool)) {

   255

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

   256

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

   257

	}

   258

	if (DO_OPER(integer)) {

   259

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

   260

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

   261

	}

   262

   263

	return NULL;

   264

}

   265

   266

   267

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

   268

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

   269

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

   270

	if (DO_OPER(integer)) {

   271

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

   272

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

   273

	}

   274

   275

	return NULL;

   276

}

   277

   278

   279

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

   280

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

   281

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

   282

	if (DO_OPER(bool)) {

   283

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

   284

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

   285

	}

   286

	if (DO_OPER(integer)) {

   287

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

   288

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

   289

	}

   290

   291

	return NULL;

   292

}

   293

   294

   295

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

   296

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

   297

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

   298

	if (DO_OPER(bool)) {

   299

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

   300

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

   301

	}

   302

	if (DO_OPER(integer)) {

   303

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

   304

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

   305

	}

   306

	if (DO_OPER(real)) {

   307

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

   308

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

   309

	}

   310

   311

	return NULL;

   312

}

   313

   314

   315

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

   316

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

   317

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

   318

	if (DO_OPER(bool)) {

   319

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

   320

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

   321

	}

   322

	if (DO_OPER(integer)) {

   323

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

   324

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

   325

	}

   326

	if (DO_OPER(real)) {

   327

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

   328

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

   329

	}

   330

   331

	return NULL;

   332

}

   333

   334

   335

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

   336

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

   337

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

   338

	if (DO_OPER(integer)) {

   339

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

   340

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

   341

	}

   342

	if (DO_OPER(real)) {

   343

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

   344

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

   345

	}

   346

   347

	return NULL;

   348

}

   349

   350

   351

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

   352

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

   353

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

   354

	if (DO_OPER(integer)) {

   355

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

   356

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

   357

	}

   358

	if (DO_OPER(real)) {

   359

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

   360

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

   361

	}

   362

   363

	return NULL;

   364

}

   365

   366

   367

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

   368

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

   369

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

   370

	if (DO_OPER(integer)) {

   371

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

   372

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

   373

	}

   374

	if (DO_OPER(real)) {

   375

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

   376

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

   377

	}

   378

   379

	return NULL;

   380

}

   381

   382

   383

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

   384

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

   385

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

   386

	if (DO_OPER(integer)) {

   387

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

   388

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

   389

	}

   390

	if (DO_OPER(real)) {

   391

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

   392

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

   393

	}

   394

   395

	return NULL;

   396

}

   397

   398

   399

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

   400

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

   401

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

   402

	if (DO_OPER(integer)) {

   403

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

   404

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

   405

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

   406

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

   407

	}

   408

	if (DO_OPER(real)) {

   410

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

   411

		/*

   412

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

   413

		 *   - representation of a number that has underflowed

   414

		 *   - representation of number that has overflowed

   415

		 *   - number is a higher precision format

   416

		 *   - A complex number

   417

		 */

   418

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

   419

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

   420

	}

   421

   422

	return NULL;

   423

}

   424

   425

   426

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

   427

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

   428

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

   429

	if (DO_OPER(integer)) {

   430

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

   431

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

   432

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

   433

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

   434

	}

   435

	if (DO_OPER(real)) {

   437

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

   438

		/*

   439

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

   440

		 *   - representation of a number that has underflowed

   441

		 *   - representation of number that has overflowed

   442

		 *   - number is a higher precision format

   443

		 *   - A complex number

   444

		 */

   445

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

   446

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

   447

	}

   448

   449

	return NULL;

   450

}

   451

   452

   453

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

   454

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

   455

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

   456

	if (DO_OPER(integer)) {

   457

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

   458

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

   459

	}

   460

	if (DO_OPER(real)) {

   462

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

   463

		/*

   464

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

   465

		 *   - representation of a number that has underflowed

   466

		 *   - representation of number that has overflowed

   467

		 *   - number is a higher precision format

   468

		 *   - A complex number

   469

		 */

   470

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

   471

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

   472

	}

   473

   474

	return NULL;

   475

}

   476

   477

   478

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

   479

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

   480

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

   481

	if (DO_OPER(integer)) {

   482

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

   483

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

   484

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

   485

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

   486

	}

   487

	if (DO_OPER(real)) {

   488

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

   489

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

   491

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

   492

		/*

   493

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

   494

		 *   - representation of a number that has underflowed

   495

		 *   - representation of number that has overflowed

   496

		 *   - number is a higher precision format

   497

		 *   - A complex number

   498

		 */

   499

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

   500

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

   501

	}

   502

   503

	return NULL;

   504

}

   505

   506

   507

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

   508

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

   509

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

   510

	if (DO_OPER(integer)) {

   511

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

   512

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

   513

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

   514

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

   515

   516

	}