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 

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

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

    50 

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

    52   if (current_display_error_level >= error_level) {                                                                         \

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

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

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

    56     fprintf(stderr, __VA_ARGS__);                                                                                           \

    57     fprintf(stderr, "\n");                                                                                                  \

    58     error_count++;                                                                                                     \

    59   }                                                                                                                         \

    60 }

    61 

    62 

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

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

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

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

    67     fprintf(stderr, __VA_ARGS__);                                                                                           \

    68     fprintf(stderr, "\n");                                                                                                  \

    69     warning_found = true;                                                                                                   \

    70 }

    71 

    72 

    73 

    74 #define DO_OPER(dtype)\

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

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

    77 

    78 

    79 #define CHECK_OVERFLOW_SUM(a, b, type)\

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

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

    82 

    83 #define CHECK_OVERFLOW_SUB(a, b, type)\

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

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

    86 

    87 

    88 

    89 

    90 

    91 constant_folding_c::constant_folding_c(symbol_c *symbol) {

    92     error_count = 0;

    93     current_display_error_level = 0;

    94 }

    95 

    96 constant_folding_c::~constant_folding_c(void) {

    97 }

    98 

    99 int constant_folding_c::get_error_count() {

   100 	return error_count;

   101 }

   102 

   103 

   104 /*********************/

   105 /* B 1.2 - Constants */

   106 /*********************/

   107 /******************************/

   108 /* B 1.2.1 - Numeric Literals */

   109 /******************************/

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

   111 	double *real_value;

   112 

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

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

   115 	symbol->const_value_real = real_value;

   116 

   117 	return NULL;

   118 }

   119 

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

   121 	int64_t *integer_value;

   122 

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

   124 	*integer_value = extract_integer_value(symbol);

   125 	symbol->const_value_integer = integer_value;

   126 

   127 	return NULL;

   128 }

   129 

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

   131 	double *real_value;

   132 

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

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

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

   136 		ERROR;

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

   138 	symbol->const_value_real = real_value;

   139 

   140 	return NULL;

   141 }

   142 

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

   144 	int64_t *integer_value;

   145 

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

   147 	*integer_value = extract_integer_value(symbol);

   148 	symbol->const_value_integer = integer_value;

   149 

   150 	return NULL;

   151 }

   152 

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

   154 

   155 	return NULL;

   156 }

   157 

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

   159 

   160 	return NULL;

   161 }

   162 

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

   164 	int64_t *integer_value;

   165 

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

   167 	*integer_value = extract_hex_value(symbol);

   168 

   169 	return NULL;

   170 }

   171 

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

   173 	int64_t *integer_value;

   174 

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

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

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

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

   179 

   180 	return NULL;

   181 }

   182 

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

   184 	double *real_value;

   185 

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

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

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

   189 		ERROR;

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

   191 	symbol->const_value_real = real_value;

   192 

   193 	return NULL;

   194 }

   195 

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

   197 

   198 	return NULL;

   199 }

   200 

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

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

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

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

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

   206 

   207 	return NULL;

   208 }

   209 

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

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

   212 	*(symbol->const_value_bool) = true;

   213 

   214 	return NULL;

   215 }

   216 

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

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

   219 	*(symbol->const_value_bool) = false;

   220 

   221 	return NULL;

   222 }

   223 

   224 /***************************************/

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

   226 /***************************************/

   227 /***********************/

   228 /* B 3.1 - Expressions */

   229 /***********************/

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

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

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

   233 	if (DO_OPER(bool)) {

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

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

   236 	}

   237 	if (DO_OPER(integer)) {

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

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

   240 	}

   241 

   242 	return NULL;

   243 }

   244 

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

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

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

   248 	if (DO_OPER(integer)) {

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

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

   251 	}

   252 

   253 	return NULL;

   254 }

   255 

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

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

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

   259 	if (DO_OPER(bool)) {

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

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

   262 	}

   263 	if (DO_OPER(integer)) {

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

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

   266 	}

   267 

   268 	return NULL;

   269 }

   270 

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

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

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

   274 	if (DO_OPER(bool)) {

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

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

   277 	}

   278 	if (DO_OPER(integer)) {

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

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

   281 	}

   282 	if (DO_OPER(real)) {

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

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

   285 	}

   286 

   287 	return NULL;

   288 }

   289 

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

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

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

   293 	if (DO_OPER(bool)) {

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

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

   296 	}

   297 	if (DO_OPER(integer)) {

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

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

   300 	}

   301 	if (DO_OPER(real)) {

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

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

   304 	}

   305 

   306 	return NULL;

   307 }

   308 

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

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

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

   312 	if (DO_OPER(integer)) {

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

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

   315 	}

   316 	if (DO_OPER(real)) {

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

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

   319 	}

   320 

   321 	return NULL;

   322 }

   323 

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

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

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

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

   342 	if (DO_OPER(integer)) {

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

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

   345 	}

   346 	if (DO_OPER(real)) {

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

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

   349 	}

   350 

   351 	return NULL;

   352 }

   353 

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

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

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

   357 	if (DO_OPER(integer)) {

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

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

   360 	}

   361 	if (DO_OPER(real)) {

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

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

   364 	}

   365 

   366 	return NULL;

   367 }

   368 

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

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

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

   372 	if (DO_OPER(integer)) {

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

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

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

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

   377 	}

   378 	if (DO_OPER(real)) {

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

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

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

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

   383 	}

   384 

   385 	return NULL;

   386 }

   387 

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

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

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

   391 	if (DO_OPER(integer)) {

   392 		if (CHECK_OVERFLOW_SUB(*(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 		if (CHECK_OVERFLOW_SUB(*(symbol->l_exp->const_value_real), *(symbol->r_exp->const_value_real), double))

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

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

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

   402 	}

   403 

   404 	return NULL;

   405 }

   406 

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

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

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

   410 	if (DO_OPER(integer)) {

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

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

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

   414 			*(symbol->const_value_integer) = 0;

   415 			return NULL;

   416 		}

   417 

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

   419 	}

   420 	if (DO_OPER(real)) {

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

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

   423 	}

   424 

   425 	return NULL;

   426 }

   427 

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

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

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

   431 	if (DO_OPER(integer)) {

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

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

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

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

   436 	}

   437 	if (DO_OPER(real)) {

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

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

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

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

   442 	}

   443 

   444 	return NULL;

   445 }

   446 

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

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

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

   450 	if (DO_OPER(integer)) {

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

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

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

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

   455 	}

   456 

   457 	return NULL;

   458 }

   459 

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

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

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

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

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

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

   466 	}

   467 

   468 	return NULL;

   469 }

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

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

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

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

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

   475 	}

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

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

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

   479 	}

   480 	return NULL;

   481 }

   482 

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

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

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

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

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

   488 	}

   489 

   490 	return NULL;

   491 }

   492 

   493 

   494