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

    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

    90

    91

    92

    93

    94

constant_folding_c::constant_folding_c(symbol_c *symbol) {

    95

    error_count = 0;

    96

    current_display_error_level = 0;

    97

}

    98

    99

constant_folding_c::~constant_folding_c(void) {

   100

}

   101

   102

int constant_folding_c::get_error_count() {

   103

	return error_count;

   104

}

   105

   106

   107

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

   108

/* B 1.2 - Constants */

   109

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

   110

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

   111

/* B 1.2.1 - Numeric Literals */

   112

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

   113

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

   114

	double *real_value;

   115

   116

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

   117

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

   118

	symbol->const_value_real = real_value;

   119

   120

	return NULL;

   121

}

   122

   123

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

   124

	int64_t *integer_value;

   125

   126

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

   127

	*integer_value = extract_integer_value(symbol);

   128

	symbol->const_value_integer = integer_value;

   129

   130

	return NULL;

   131

}

   132

   133

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

   134

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

   135

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

   136

		ERROR;

   139

	return NULL;

   140

}

   141

   142

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

   143

	int64_t *integer_value;

   144

   145

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

   146

	*integer_value = extract_integer_value(symbol);

   147

	symbol->const_value_integer = integer_value;

   148

   149

	return NULL;

   150

}

   151

   152

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

   153

   154

	return NULL;

   155

}

   156

   157

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

   158

   159

	return NULL;

   160

}

   161

   162

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

   165

   166

	return NULL;

   167

}

   168

   169

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

   170

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

   171

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

   173

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

   174

   175

	return NULL;

   176

}

   177

   178

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

   179

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

   183

   184

	return NULL;

   185

}

   186

   187

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

   188

   189

	return NULL;

   190

}

   191

   192

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

   193

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

   194

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

   195

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

   196

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

   197

   198

	return NULL;

   199

}

   200

   201

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

   202

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

   203

	*(symbol->const_value_bool) = true;

   204

   205

	return NULL;

   206

}

   207

   208

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

   209

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

   210

	*(symbol->const_value_bool) = false;

   211

   212

	return NULL;

   213

}

   214

   215

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

   216

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

   217

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

   218

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

   219

/* B 3.1 - Expressions */

   220

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

   221

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

   222

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

   223

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

   224

	if (DO_OPER(bool)) {

   225

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

   226

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

   227

	}

   228

	if (DO_OPER(integer)) {

   229

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

   230

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

   231

	}

   232

   233

	return NULL;

   234

}

   235

   236

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

   237

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

   238

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

   239

	if (DO_OPER(integer)) {

   240

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

   241

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

   242

	}

   243

   244

	return NULL;

   245

}

   246

   247

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

   248

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

   249

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

   250

	if (DO_OPER(bool)) {

   251

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

   252

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

   253

	}

   254

	if (DO_OPER(integer)) {

   255

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

   256

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

   257

	}

   258

   259

	return NULL;

   260

}

   261

   262

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

   263

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

   264

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

   265

	if (DO_OPER(bool)) {

   266

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

   267

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

   268

	}

   269

	if (DO_OPER(integer)) {

   270

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

   271

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

   272

	}

   273

	if (DO_OPER(real)) {

   274

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

   275

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

   276

	}

   277

   278

	return NULL;

   279

}

   280

   281

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

   282

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

   283

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

   284

	if (DO_OPER(bool)) {

   285

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

   286

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

   287

	}

   288

	if (DO_OPER(integer)) {

   289

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

   290

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

   291

	}

   292

	if (DO_OPER(real)) {

   293

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

   294

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

   295

	}

   296

   297

	return NULL;

   298

}

   299

   300

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

   301

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

   302

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

   303

	if (DO_OPER(integer)) {

   304

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

   305

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

   306

	}

   307

	if (DO_OPER(real)) {

   308

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

   309

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

   310

	}

   311

   312

	return NULL;

   313

}

   314

   315

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

   316

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

   317

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

   318

	if (DO_OPER(integer)) {

   319

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

   320

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

   321

	}

   322

	if (DO_OPER(real)) {

   323

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

   324

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

   325

	}

   326

   327

	return NULL;

   328

}

   329

   330

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

   331

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

   332

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

   333

	if (DO_OPER(integer)) {

   334

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

   335

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

   336

	}

   337

	if (DO_OPER(real)) {

   338

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

   339

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

   340

	}

   341

   342

	return NULL;

   343

}

   344

   345

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

   346

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

   347

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

   348

	if (DO_OPER(integer)) {

   349

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

   350

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

   351

	}

   352

	if (DO_OPER(real)) {

   353

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

   354

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

   355

	}

   356

   357

	return NULL;

   358

}

   359

   360

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

   361

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

   362

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

   363

	if (DO_OPER(integer)) {

   364

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

   365

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

   366

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

   367

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

   368

	}

   369

	if (DO_OPER(real)) {

   370

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

   371

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

   381

	}

   382

   383

	return NULL;

   384

}

   385

   386

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

   387

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

   388

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

   389

	if (DO_OPER(integer)) {

   390

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

   391

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

   392

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

   393

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

   394

	}

   395

	if (DO_OPER(real)) {

   396

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

   397

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

   407

	}

   408

   409

	return NULL;

   410

}

   411

   412

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

   413

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

   414

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

   415

	if (DO_OPER(integer)) {

   416

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

   417

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

   418

	}

   419

	if (DO_OPER(real)) {

   420

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

   421

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

   431

	}

   432

   433

	return NULL;

   434

}

   435

   436

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

   437

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

   438

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

   439

	if (DO_OPER(integer)) {

   440

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

   441

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

   442

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

   443

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

   444

	}

   445

	if (DO_OPER(real)) {

   446

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

   447

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

   448

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

   449

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

   459

	}

   460

   461

	return NULL;

   462

}

   463

   464

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

   465

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

   466

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

   467

	if (DO_OPER(integer)) {

   468

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

   469

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

   470

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

   471

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

   473

	}

   474

   475

	return NULL;

   476

}

   477

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   493

	}

   494

   495

	return NULL;

   496

}

   497

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

   498

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

   499

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

   500

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

   501

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

   502

	}

   503

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

   504

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

   505

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

   506

	}

   507

	return NULL;

   508

}

   509

   510

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

   511

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

   512

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

   513

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

   514

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

   515

	}

   516

   517

	return NULL;

   518

}

   519

   520

   521