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

    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

    75

#define DO_OPER(dtype)\

    76

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

    77

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

    78

    79

    80

#define CHECK_OVERFLOW_SUM(a, b, type)\

    81

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

    82

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

    83

    84

#define CHECK_OVERFLOW_SUB(a, b, type)\

    85

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

    86

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

    87

    88

    89

    90

    91

    92

constant_folding_c::constant_folding_c(symbol_c *symbol) {

    93

    error_count = 0;

    94

    current_display_error_level = 0;

    95

}

    96

    97

constant_folding_c::~constant_folding_c(void) {

    98

}

    99

   100

int constant_folding_c::get_error_count() {

   101

	return error_count;

   102

}

   103

   104

   105

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

   106

/* B 1.2 - Constants */

   107

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

   108

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

   109

/* B 1.2.1 - Numeric Literals */

   110

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

   111

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

   112

	double *real_value;

   113

   114

	real_value = (double *)malloc(sizeof(double));

   115

	sscanf(symbol->value, "%lf", real_value);

   116

	symbol->const_value_real = real_value;

   117

   118

	return NULL;

   119

}

   120

   121

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

   122

	int64_t *integer_value;

   123

   124

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

   125

	*integer_value = extract_integer_value(symbol);

   126

	symbol->const_value_integer = integer_value;

   127

   128

	return NULL;

   129

}

   130

   131

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

   132

	double *real_value;

   133

   134

	real_value = (double *)malloc(sizeof(double));

   135

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

   136

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

   137

		ERROR;

   138

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

   139

	symbol->const_value_real = real_value;

   140

   141

	return NULL;

   142

}

   143

   144

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

   145

	int64_t *integer_value;

   146

   147

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

   148

	*integer_value = extract_integer_value(symbol);

   149

	symbol->const_value_integer = integer_value;

   150

   151

	return NULL;

   152

}

   153

   154

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

   155

   156

	return NULL;

   157

}

   158

   159

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

   160

   161

	return NULL;

   162

}

   163

   164

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

   165

	int64_t *integer_value;

   166

   167

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

   168

	*integer_value = extract_hex_value(symbol);

   169

   170

	return NULL;

   171

}

   172

   173

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

   174

	int64_t *integer_value;

   175

   176

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

   177

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

   178

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

   179

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

   180

   181

	return NULL;

   182

}

   183

   184

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

   185

	double *real_value;

   186

   187

	real_value = (double *)malloc(sizeof(double));

   188

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

   189

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

   190

		ERROR;

   191

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

   192

	symbol->const_value_real = real_value;

   193

   194

	return NULL;

   195

}

   196

   197

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

   198

   199

	return NULL;

   200

}

   201

   202

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

   203

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

   204

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

   205

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

   206

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

   207

   208

	return NULL;

   209

}

   210

   211

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

   212

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

   213

	*(symbol->const_value_bool) = true;

   214

   215

	return NULL;

   216

}

   217

   218

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

   219

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

   220

	*(symbol->const_value_bool) = false;

   221

   222

	return NULL;

   223

}

   224

   225

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

   226

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

   227

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

   228

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

   229

/* B 3.1 - Expressions */

   230

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

   231

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

   232

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

   233

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

   234

	if (DO_OPER(bool)) {

   235

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

   236

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

   237

	}

   238

	if (DO_OPER(integer)) {

   239

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

   240

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

   241

	}

   242

   243

	return NULL;

   244

}

   245

   246

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

   247

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

   248

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

   249

	if (DO_OPER(integer)) {

   250

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

   251

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

   252

	}

   253

   254

	return NULL;

   255

}

   256

   257

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

   258

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

   259

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

   260

	if (DO_OPER(bool)) {

   261

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

   262

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

   263

	}

   264

	if (DO_OPER(integer)) {

   265

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

   266

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

   267

	}

   268

   269

	return NULL;

   270

}

   271

   272

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

   273

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

   274

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

   275

	if (DO_OPER(bool)) {

   276

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

   277

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

   278

	}

   279

	if (DO_OPER(integer)) {

   280

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

   281

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

   282

	}

   283

	if (DO_OPER(real)) {

   284

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

   285

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

   286

	}

   287

   288

	return NULL;

   289

}

   290

   291

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

   292

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

   293

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

   294

	if (DO_OPER(bool)) {

   295

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

   296

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

   297

	}

   298

	if (DO_OPER(integer)) {

   299

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

   300

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

   301

	}

   302

	if (DO_OPER(real)) {

   303

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

   304

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

   305

	}

   306

   307

	return NULL;

   308

}

   309

   310

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

   311

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

   312

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

   313

	if (DO_OPER(integer)) {

   314

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

   315

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

   316

	}

   317

	if (DO_OPER(real)) {

   318

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

   319

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

   320

	}

   321

   322

	return NULL;

   323

}

   324

   325

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

   326

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

   327

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

   328

	if (DO_OPER(integer)) {

   329

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

   330

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

   331

	}

   332

	if (DO_OPER(real)) {

   333

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

   334

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

   335

	}

   336

   337

	return NULL;

   338

}

   339

   340

void *constant_folding_c::visit(le_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

   355

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

   356

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

   357

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

   358

	if (DO_OPER(integer)) {

   359

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

   360

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

   361

	}

   362

	if (DO_OPER(real)) {

   363

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

   364

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

   365

	}

   366

   367

	return NULL;

   368

}

   369

   370

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

   371

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

   372

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

   373

	if (DO_OPER(integer)) {

   374

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

   375

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

   376

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

   377

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

   378

	}

   379

	if (DO_OPER(real)) {

   380

		if (CHECK_OVERFLOW_SUM(*(symbol->l_exp->const_value_real), *(symbol->r_exp->const_value_real), double))

   381

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

   382

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

   383

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

   384

	}

   385

   386

	return NULL;

   387

}

   388

   389

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

   390

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

   391

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

   392

	if (DO_OPER(integer)) {

   393

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

   394

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

   395

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

   396

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

   397

	}

   398

	if (DO_OPER(real)) {

   399

		if (CHECK_OVERFLOW_SUB(*(symbol->l_exp->const_value_real), *(symbol->r_exp->const_value_real), double))

   400

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

   401

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

   402

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

   403

	}

   404

   405

	return NULL;

   406

}

   407

   408

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

   409

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

   410

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

   411

	if (DO_OPER(integer)) {

   412

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

   413

		if ((*(symbol->l_exp->const_value_integer) == 0) ||

   414

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

   415

			*(symbol->const_value_integer) = 0;

   416

			return NULL;

   417

		}

   418

   419

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

   420

	}

   421

	if (DO_OPER(real)) {

   422

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

   423

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

   424

	}

   425

   426

	return NULL;

   427

}

   428

   429

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

   430

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

   431

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

   432

	if (DO_OPER(integer)) {

   433

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

   434

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

   435

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

   436

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

   437

	}

   438

	if (DO_OPER(real)) {

   439

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

   440

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

   441

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

   442

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

   443

	}

   444

   445

	return NULL;

   446

}

   447

   448

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

   449

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

   450

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

   451

	if (DO_OPER(integer)) {

   452

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

   453

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

   454

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

   455

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

   456

	}

   457

   458

	return NULL;

   459

}

   460

   461

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

   462

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

   463

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

   464

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

   465

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

   466

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

   467

	}

   468

   469

	return NULL;

   470

}

   471

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

   472

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

   473

	if (NULL != symbol->exp->const_value_integer) {

   474

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

   475

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

   476

	}

   477

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

   478

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

   479

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

   480

	}

   481

	return NULL;

   482

}

   483

   484

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

   485

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

   486

	if (NULL != symbol->exp->const_value_bool) {

   487

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

   488

		*(symbol->const_value_bool) = !*(symbol->exp->const_value_bool);

   489

	}

   490

   491

	return NULL;

   492

}

   493

   494

   495