Mercurial Mercurial > matiec / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
stage3/fill_candidate_datatypes.cc
changeset 603 a45a62dd6df9
parent 558 9273dfc5fa7c
child 604 2989051a0a64
equal deleted inserted replaced
602:456add88d64c 603:a45a62dd6df9 
    61 #include <list>
 
    61 #include <list>
 
    62 #include <string>
 
    62 #include <string>
 
    63 #include <string.h>
 
    63 #include <string.h>
 
    64 #include <strings.h>
 
    64 #include <strings.h>
 
    65 
    65 
       
    66 #define GET_CVALUE(dtype, symbol)             ((symbol)->const_value_##dtype->value)
 
       
    67 #define IS_UNDEF(dtype, symbol)               (NULL == (symbol)->const_value_##dtype)
 
       
    68 #define VALID_CVALUE(dtype, symbol)           ((NULL != (symbol)->const_value_##dtype) && (symbol_c::cs_const_value == (symbol)->const_value_##dtype->status))
 
       
    69 #define IS_OVERFLOW(dtype, symbol)            (symbol_c::cs_overflow == (symbol)->const_value_##dtype->status)
 
       
    70 
    66 /* set to 1 to see debug info during execution */
 
    71 /* set to 1 to see debug info during execution */
 
    67 static int debug = 0;
 
    72 static int debug = 0;
 
    68 
    73 
    69 fill_candidate_datatypes_c::fill_candidate_datatypes_c(symbol_c *ignore) {
 
    74 fill_candidate_datatypes_c::fill_candidate_datatypes_c(symbol_c *ignore) {
 
    70 }
 
    75 }
 
   103     
   108     
   104 bool fill_candidate_datatypes_c::add_2datatypes_to_candidate_list(symbol_c *symbol, symbol_c *datatype1, symbol_c *datatype2) {
 
   109 bool fill_candidate_datatypes_c::add_2datatypes_to_candidate_list(symbol_c *symbol, symbol_c *datatype1, symbol_c *datatype2) {
 
   105   add_datatype_to_candidate_list(symbol, datatype1);
 
   110   add_datatype_to_candidate_list(symbol, datatype1);
 
   106   add_datatype_to_candidate_list(symbol, datatype2);
 
   111   add_datatype_to_candidate_list(symbol, datatype2);
 
   107   return true;
 
   112   return true;
 
       
   113 }
 
       
   114 
       
   115 void fill_candidate_datatypes_c::remove_incompatible_datatypes(symbol_c *symbol) {
 
       
   116   /* Remove unsigned data types */
 
       
   117   if (! IS_UNDEF( uint64, symbol)) {
 
       
   118     if (VALID_CVALUE( uint64, symbol)) {
 
       
   119       uint64_t value = GET_CVALUE(uint64, symbol);
 
       
   120       if (value > 1) {
 
       
   121     	  remove_from_candidate_datatype_list(&search_constant_type_c::bool_type_name,       symbol->candidate_datatypes);
 
       
   122     	  remove_from_candidate_datatype_list(&search_constant_type_c::safebool_type_name,   symbol->candidate_datatypes);
 
       
   123       }
 
       
   124       if (value > UINT8_MAX  ) {
 
       
   125     	  remove_from_candidate_datatype_list(&search_constant_type_c::usint_type_name,      symbol->candidate_datatypes);
 
       
   126     	  remove_from_candidate_datatype_list(&search_constant_type_c::safeusint_type_name,  symbol->candidate_datatypes);
 
       
   127 	      remove_from_candidate_datatype_list(&search_constant_type_c::byte_type_name,       symbol->candidate_datatypes);
 
       
   128 	      remove_from_candidate_datatype_list(&search_constant_type_c::safebyte_type_name,   symbol->candidate_datatypes);
 
       
   129       }
 
       
   130       if (value > UINT16_MAX ) {
 
       
   131     	  remove_from_candidate_datatype_list(&search_constant_type_c::uint_type_name,       symbol->candidate_datatypes);
 
       
   132     	  remove_from_candidate_datatype_list(&search_constant_type_c::safeuint_type_name,   symbol->candidate_datatypes);
 
       
   133           remove_from_candidate_datatype_list(&search_constant_type_c::word_type_name,       symbol->candidate_datatypes);
 
       
   134           remove_from_candidate_datatype_list(&search_constant_type_c::safeword_type_name,   symbol->candidate_datatypes);
 
       
   135       }
 
       
   136       if (value > UINT32_MAX ) {
 
       
   137     	  remove_from_candidate_datatype_list(&search_constant_type_c::udint_type_name,      symbol->candidate_datatypes);
 
       
   138     	  remove_from_candidate_datatype_list(&search_constant_type_c::safeudint_type_name,  symbol->candidate_datatypes);
 
       
   139           remove_from_candidate_datatype_list(&search_constant_type_c::dword_type_name,      symbol->candidate_datatypes);
 
       
   140           remove_from_candidate_datatype_list(&search_constant_type_c::safedword_type_name,  symbol->candidate_datatypes);
 
       
   141       }
 
       
   142     }
 
       
   143     if (IS_OVERFLOW( uint64, symbol)) {
 
       
   144   	      remove_from_candidate_datatype_list(&search_constant_type_c::bool_type_name,       symbol->candidate_datatypes);
 
       
   145   	      remove_from_candidate_datatype_list(&search_constant_type_c::safebool_type_name,   symbol->candidate_datatypes);
 
       
   146     	  remove_from_candidate_datatype_list(&search_constant_type_c::usint_type_name,      symbol->candidate_datatypes);
 
       
   147     	  remove_from_candidate_datatype_list(&search_constant_type_c::safeusint_type_name,  symbol->candidate_datatypes);
 
       
   148 	      remove_from_candidate_datatype_list(&search_constant_type_c::byte_type_name,       symbol->candidate_datatypes);
 
       
   149 	      remove_from_candidate_datatype_list(&search_constant_type_c::safebyte_type_name,   symbol->candidate_datatypes);
 
       
   150     	  remove_from_candidate_datatype_list(&search_constant_type_c::uint_type_name,       symbol->candidate_datatypes);
 
       
   151     	  remove_from_candidate_datatype_list(&search_constant_type_c::safeuint_type_name,   symbol->candidate_datatypes);
 
       
   152           remove_from_candidate_datatype_list(&search_constant_type_c::word_type_name,       symbol->candidate_datatypes);
 
       
   153           remove_from_candidate_datatype_list(&search_constant_type_c::safeword_type_name,   symbol->candidate_datatypes);
 
       
   154     	  remove_from_candidate_datatype_list(&search_constant_type_c::udint_type_name,      symbol->candidate_datatypes);
 
       
   155     	  remove_from_candidate_datatype_list(&search_constant_type_c::safeudint_type_name,  symbol->candidate_datatypes);
 
       
   156           remove_from_candidate_datatype_list(&search_constant_type_c::dword_type_name,      symbol->candidate_datatypes);
 
       
   157           remove_from_candidate_datatype_list(&search_constant_type_c::safedword_type_name,  symbol->candidate_datatypes);
 
       
   158     	  remove_from_candidate_datatype_list(&search_constant_type_c::ulint_type_name,      symbol->candidate_datatypes);
 
       
   159     	  remove_from_candidate_datatype_list(&search_constant_type_c::safeulint_type_name,  symbol->candidate_datatypes);
 
       
   160           remove_from_candidate_datatype_list(&search_constant_type_c::lword_type_name,      symbol->candidate_datatypes);
 
       
   161           remove_from_candidate_datatype_list(&search_constant_type_c::safelword_type_name,  symbol->candidate_datatypes);
 
       
   162     }
 
       
   163   }
 
       
   164   /* Remove signed data types */
 
       
   165   if (! IS_UNDEF( int64, symbol)) {
 
       
   166  	if (VALID_CVALUE( int64, symbol)) {
 
       
   167       int64_t value = GET_CVALUE(int64, symbol);
 
       
   168       if (value < 0 || value > 1) {
 
       
   169     	  remove_from_candidate_datatype_list(&search_constant_type_c::bool_type_name,       symbol->candidate_datatypes);
 
       
   170     	  remove_from_candidate_datatype_list(&search_constant_type_c::safebool_type_name,   symbol->candidate_datatypes);
 
       
   171       }
 
       
   172  	  if  ((value < INT8_MIN  ) || (value > INT8_MAX )) {
 
       
   173  	      remove_from_candidate_datatype_list(&search_constant_type_c::sint_type_name,       symbol->candidate_datatypes);
 
       
   174  	      remove_from_candidate_datatype_list(&search_constant_type_c::safesint_type_name,   symbol->candidate_datatypes);
 
       
   175 	      remove_from_candidate_datatype_list(&search_constant_type_c::byte_type_name,       symbol->candidate_datatypes);
 
       
   176 	      remove_from_candidate_datatype_list(&search_constant_type_c::safebyte_type_name,   symbol->candidate_datatypes);
 
       
   177  	  }
 
       
   178       if  ((value < INT16_MIN ) || (value > INT16_MAX)) {
 
       
   179           remove_from_candidate_datatype_list(&search_constant_type_c::int_type_name,        symbol->candidate_datatypes);
 
       
   180           remove_from_candidate_datatype_list(&search_constant_type_c::safeint_type_name,    symbol->candidate_datatypes);
 
       
   181           remove_from_candidate_datatype_list(&search_constant_type_c::word_type_name,       symbol->candidate_datatypes);
 
       
   182           remove_from_candidate_datatype_list(&search_constant_type_c::safeword_type_name,   symbol->candidate_datatypes);
 
       
   183       }
 
       
   184       if  ((value < INT32_MIN ) || (value > INT32_MAX)) {
 
       
   185           remove_from_candidate_datatype_list(&search_constant_type_c::dint_type_name,       symbol->candidate_datatypes);
 
       
   186           remove_from_candidate_datatype_list(&search_constant_type_c::safedint_type_name,   symbol->candidate_datatypes);
 
       
   187           remove_from_candidate_datatype_list(&search_constant_type_c::dword_type_name,      symbol->candidate_datatypes);
 
       
   188           remove_from_candidate_datatype_list(&search_constant_type_c::safedword_type_name,  symbol->candidate_datatypes);
 
       
   189       }
 
       
   190  	}
 
       
   191     if  (IS_OVERFLOW( int64, symbol)) {
 
       
   192     	  /* Not exist a valid signed integer data types it can represent the current value */
 
       
   193     	  remove_from_candidate_datatype_list(&search_constant_type_c::sint_type_name,       symbol->candidate_datatypes);
 
       
   194     	  remove_from_candidate_datatype_list(&search_constant_type_c::safesint_type_name,   symbol->candidate_datatypes);
 
       
   195     	  remove_from_candidate_datatype_list(&search_constant_type_c::int_type_name,        symbol->candidate_datatypes);
 
       
   196     	  remove_from_candidate_datatype_list(&search_constant_type_c::safeint_type_name,    symbol->candidate_datatypes);
 
       
   197     	  remove_from_candidate_datatype_list(&search_constant_type_c::dint_type_name,       symbol->candidate_datatypes);
 
       
   198     	  remove_from_candidate_datatype_list(&search_constant_type_c::safedint_type_name,   symbol->candidate_datatypes);
 
       
   199     	  remove_from_candidate_datatype_list(&search_constant_type_c::lint_type_name,       symbol->candidate_datatypes);
 
       
   200     	  remove_from_candidate_datatype_list(&search_constant_type_c::safelint_type_name,   symbol->candidate_datatypes);
 
       
   201 	      remove_from_candidate_datatype_list(&search_constant_type_c::byte_type_name,       symbol->candidate_datatypes);
 
       
   202 	      remove_from_candidate_datatype_list(&search_constant_type_c::safebyte_type_name,   symbol->candidate_datatypes);
 
       
   203           remove_from_candidate_datatype_list(&search_constant_type_c::word_type_name,       symbol->candidate_datatypes);
 
       
   204           remove_from_candidate_datatype_list(&search_constant_type_c::safeword_type_name,   symbol->candidate_datatypes);
 
       
   205           remove_from_candidate_datatype_list(&search_constant_type_c::dword_type_name,      symbol->candidate_datatypes);
 
       
   206           remove_from_candidate_datatype_list(&search_constant_type_c::safedword_type_name,  symbol->candidate_datatypes);
 
       
   207           remove_from_candidate_datatype_list(&search_constant_type_c::lword_type_name,      symbol->candidate_datatypes);
 
       
   208           remove_from_candidate_datatype_list(&search_constant_type_c::safelword_type_name,  symbol->candidate_datatypes);
 
       
   209     }
 
       
   210   }
 
       
   211   /* Remove floating point data types */
 
       
   212   if (! IS_UNDEF( real64, symbol)) {
 
       
   213 	  if (VALID_CVALUE( real64, symbol)) {
 
       
   214 		  real64_t value = GET_CVALUE(real64, symbol);
 
       
   215 		  /*  We need a way to understand when lost precision happen and overflow for single precision.
 
       
   216 		   *  In this way we can remove REAL data type when a value has a mantissa or exponent too large.
 
       
   217 		   */
 
       
   218 	  }
 
       
   219 	  if  (IS_OVERFLOW( real64, symbol)) {
 
       
   220 		  /* Not exist a valid real data types that it can represent the current value */
 
       
   221 	      remove_from_candidate_datatype_list(&search_constant_type_c::real_type_name,      symbol->candidate_datatypes);
 
       
   222 	      remove_from_candidate_datatype_list(&search_constant_type_c::safereal_type_name,  symbol->candidate_datatypes);
 
       
   223 	      remove_from_candidate_datatype_list(&search_constant_type_c::lreal_type_name,     symbol->candidate_datatypes);
 
       
   224 	      remove_from_candidate_datatype_list(&search_constant_type_c::safelreal_type_name, symbol->candidate_datatypes);
 
       
   225 	  }
 
       
   226   }
 
   108 }
 
   227 }
 
   109     
   228     
   110 
   229 
   111 /* returns true if compatible function/FB invocation, otherwise returns false */
 
   230 /* returns true if compatible function/FB invocation, otherwise returns false */
 
   112 /* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */
 
   231 /* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */
 
   346 
   465 
   347 	for(unsigned int i = 0; i < l_expr->candidate_datatypes.size(); i++)
 
   466 	for(unsigned int i = 0; i < l_expr->candidate_datatypes.size(); i++)
 
   348 		for(unsigned int j = 0; j < r_expr->candidate_datatypes.size(); j++)
 
   467 		for(unsigned int j = 0; j < r_expr->candidate_datatypes.size(); j++)
 
   349 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */
 
   468 			/* NOTE: add_datatype_to_candidate_list() will only really add the datatype if it is != NULL !!! */
 
   350 			add_datatype_to_candidate_list(symbol, widening_conversion(l_expr->candidate_datatypes[i], r_expr->candidate_datatypes[j], widen_table));
 
   469 			add_datatype_to_candidate_list(symbol, widening_conversion(l_expr->candidate_datatypes[i], r_expr->candidate_datatypes[j], widen_table));
 
   351 
   470 	remove_incompatible_datatypes(symbol);
 
   352 	if (debug) std::cout <<  "[" << l_expr->candidate_datatypes.size() << "," << r_expr->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
   471 	if (debug) std::cout <<  "[" << l_expr->candidate_datatypes.size() << "," << r_expr->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
   353 	return NULL;
 
   472 	return NULL;
 
   354 }
 
   473 }
 
   355 
   474 
   356 
   475 
   380 /* B 1.2.1 - Numeric Literals */
 
   499 /* B 1.2.1 - Numeric Literals */
 
   381 /******************************/
 
   500 /******************************/
 
   382 #define sizeoftype(symbol) get_sizeof_datatype_c::getsize(symbol)
 
   501 #define sizeoftype(symbol) get_sizeof_datatype_c::getsize(symbol)
 
   383 
   502 
   384 void *fill_candidate_datatypes_c::handle_any_integer(symbol_c *symbol) {
 
   503 void *fill_candidate_datatypes_c::handle_any_integer(symbol_c *symbol) {
 
   385 	int calc_size = sizeoftype(symbol);
 
   504 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name,  &search_constant_type_c::safebool_type_name);
 
   386 
   505 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::byte_type_name,  &search_constant_type_c::safebyte_type_name);
 
   387 	if (calc_size <= sizeoftype(&search_constant_type_c::bool_type_name))
 
   506 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::word_type_name,  &search_constant_type_c::safeword_type_name);
 
   388 	        add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
   507 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dword_type_name, &search_constant_type_c::safedword_type_name);
 
   389 	if (calc_size <= sizeoftype(&search_constant_type_c::byte_type_name))
 
   508 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lword_type_name, &search_constant_type_c::safelword_type_name);
 
   390 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::byte_type_name, &search_constant_type_c::safebyte_type_name);
 
   509 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::sint_type_name,  &search_constant_type_c::safesint_type_name);
 
   391 	if (calc_size <= sizeoftype(&search_constant_type_c::word_type_name))
 
   510 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::int_type_name,   &search_constant_type_c::safeint_type_name);
 
   392 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::word_type_name, &search_constant_type_c::safeword_type_name);
 
   511 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dint_type_name,  &search_constant_type_c::safedint_type_name);
 
   393 	if (calc_size <= sizeoftype(&search_constant_type_c::dword_type_name))
 
   512 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lint_type_name,  &search_constant_type_c::safelint_type_name);
 
   394 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dword_type_name, &search_constant_type_c::safedword_type_name);
 
   513 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::usint_type_name, &search_constant_type_c::safeusint_type_name);
 
   395 	if (calc_size <= sizeoftype(&search_constant_type_c::lword_type_name))
 
   514 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::uint_type_name,  &search_constant_type_c::safeuint_type_name);
 
   396 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lword_type_name, &search_constant_type_c::safelword_type_name);
 
   515 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::udint_type_name, &search_constant_type_c::safeudint_type_name);
 
   397 
   516 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::ulint_type_name, &search_constant_type_c::safeulint_type_name);
 
   398 	if (calc_size < sizeoftype(&search_constant_type_c::sint_type_name))
 
   517 	remove_incompatible_datatypes(symbol);
 
   399 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::sint_type_name, &search_constant_type_c::safesint_type_name);
 
       
   400 	if (calc_size < sizeoftype(&search_constant_type_c::int_type_name))
 
       
   401 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::int_type_name, &search_constant_type_c::safeint_type_name);
 
       
   402 	if (calc_size < sizeoftype(&search_constant_type_c::dint_type_name))
 
       
   403 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dint_type_name, &search_constant_type_c::safedint_type_name);
 
       
   404 	if (calc_size < sizeoftype(&search_constant_type_c::lint_type_name))
 
       
   405 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lint_type_name, &search_constant_type_c::safelint_type_name);
 
       
   406 	if (calc_size <= sizeoftype(&search_constant_type_c::usint_type_name))
 
       
   407 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::usint_type_name, &search_constant_type_c::safeusint_type_name);
 
       
   408 	if (calc_size <= sizeoftype(&search_constant_type_c::uint_type_name))
 
       
   409 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::uint_type_name, &search_constant_type_c::safeuint_type_name);
 
       
   410 	if (calc_size <= sizeoftype(&search_constant_type_c::udint_type_name))
 
       
   411 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::udint_type_name, &search_constant_type_c::safeudint_type_name);
 
       
   412 	if (calc_size <= sizeoftype(&search_constant_type_c::ulint_type_name))
 
       
   413 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::ulint_type_name, &search_constant_type_c::safeulint_type_name);
 
       
   414 
       
   415 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
   518 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
   416 	return NULL;
 
   519 	return NULL;
 
   417 }
 
   520 }
 
   418 
   521 
   419 
   522 
   420 
   523 
   421 void *fill_candidate_datatypes_c::handle_any_real(symbol_c *symbol) {
 
   524 void *fill_candidate_datatypes_c::handle_any_real(symbol_c *symbol) {
 
   422 	int calc_size = sizeoftype(symbol);
 
   525 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::real_type_name,  &search_constant_type_c::safereal_type_name);
 
   423 
   526 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lreal_type_name, &search_constant_type_c::safelreal_type_name);
 
   424 	if (calc_size <= sizeoftype(&search_constant_type_c::real_type_name))
 
   527 	remove_incompatible_datatypes(symbol);
 
   425 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::real_type_name,  &search_constant_type_c::safereal_type_name);
 
       
   426 	if (calc_size <= sizeoftype(&search_constant_type_c::lreal_type_name))
 
       
   427 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lreal_type_name, &search_constant_type_c::safelreal_type_name);
 
       
   428 	if (debug) std::cout << "ANY_REAL [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   528 	if (debug) std::cout << "ANY_REAL [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   429 	return NULL;
 
   529 	return NULL;
 
   430 }
 
   530 }
 
   431 
   531 
   432 
   532 
   433 
   533 
   434 void *fill_candidate_datatypes_c::handle_any_literal(symbol_c *symbol, symbol_c *symbol_value, symbol_c *symbol_type) {
 
   534 void *fill_candidate_datatypes_c::handle_any_literal(symbol_c *symbol, symbol_c *symbol_value, symbol_c *symbol_type) {
 
   435 	symbol_value->accept(*this);
 
   535 	symbol_value->accept(*this);
 
   436 	if (search_in_candidate_datatype_list(symbol_type, symbol_value->candidate_datatypes) >= 0)
 
   536 	if (search_in_candidate_datatype_list(symbol_type, symbol_value->candidate_datatypes) >= 0)
 
   437 		add_datatype_to_candidate_list(symbol, symbol_type);
 
   537 		add_datatype_to_candidate_list(symbol, symbol_type);
 
       
   538 	remove_incompatible_datatypes(symbol);
 
   438 	if (debug) std::cout << "XXX_LITERAL [" << symbol->candidate_datatypes.size() << "]\n";
 
   539 	if (debug) std::cout << "XXX_LITERAL [" << symbol->candidate_datatypes.size() << "]\n";
 
   439 	return NULL;
 
   540 	return NULL;
 
   440 }
 
   541 }
 
   441 
   542 
   442 
   543 
   445 void *fill_candidate_datatypes_c::visit(neg_real_c *symbol) {return handle_any_real(symbol);}
 
   546 void *fill_candidate_datatypes_c::visit(neg_real_c *symbol) {return handle_any_real(symbol);}
 
   446 
   547 
   447 
   548 
   448 
   549 
   449 void *fill_candidate_datatypes_c::visit(neg_integer_c *symbol) {
 
   550 void *fill_candidate_datatypes_c::visit(neg_integer_c *symbol) {
 
   450 	int calc_size = sizeoftype(symbol);
 
   551 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::int_type_name, &search_constant_type_c::safeint_type_name);
 
   451 
   552 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::sint_type_name, &search_constant_type_c::safesint_type_name);
 
   452 	if (calc_size <= sizeoftype(&search_constant_type_c::int_type_name))
 
   553 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dint_type_name, &search_constant_type_c::safedint_type_name);
 
   453 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::int_type_name, &search_constant_type_c::safeint_type_name);
 
   554 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lint_type_name, &search_constant_type_c::safelint_type_name);
 
   454 	if (calc_size <= sizeoftype(&search_constant_type_c::sint_type_name))
 
   555 	remove_incompatible_datatypes(symbol);
 
   455 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::sint_type_name, &search_constant_type_c::safesint_type_name);
 
       
   456 	if (calc_size <= sizeoftype(&search_constant_type_c::dint_type_name))
 
       
   457 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dint_type_name, &search_constant_type_c::safedint_type_name);
 
       
   458 	if (calc_size <= sizeoftype(&search_constant_type_c::lint_type_name))
 
       
   459 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lint_type_name, &search_constant_type_c::safelint_type_name);
 
       
   460 	if (debug) std::cout << "neg ANY_INT [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   556 	if (debug) std::cout << "neg ANY_INT [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   461 	return NULL;
 
   557 	return NULL;
 
   462 }
 
   558 }
 
   463 
   559 
   464 
   560 
   491 }
 
   587 }
 
   492 
   588 
   493 
   589 
   494 void *fill_candidate_datatypes_c::visit(boolean_true_c *symbol) {
 
   590 void *fill_candidate_datatypes_c::visit(boolean_true_c *symbol) {
 
   495 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
   591 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
       
   592 	remove_incompatible_datatypes(symbol);
 
   496 	return NULL;
 
   593 	return NULL;
 
   497 }
 
   594 }
 
   498 
   595 
   499 void *fill_candidate_datatypes_c::visit(boolean_false_c *symbol) {
 
   596 void *fill_candidate_datatypes_c::visit(boolean_false_c *symbol) {
 
   500 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
   597 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
       
   598 	remove_incompatible_datatypes(symbol);
 
   501 	return NULL;
 
   599 	return NULL;
 
   502 }
 
   600 }
 
   503 
   601 
   504 /*******************************/
 
   602 /*******************************/
 
   505 /* B.1.2.2   Character Strings */
 
   603 /* B.1.2.2   Character Strings */
 
   506 /*******************************/
 
   604 /*******************************/
 
   507 void *fill_candidate_datatypes_c::visit(double_byte_character_string_c *symbol) {
 
   605 void *fill_candidate_datatypes_c::visit(double_byte_character_string_c *symbol) {
 
   508 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::wstring_type_name, &search_constant_type_c::safewstring_type_name);
 
   606 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::wstring_type_name, &search_constant_type_c::safewstring_type_name);
 
       
   607 	remove_incompatible_datatypes(symbol);
 
   509 	return NULL;
 
   608 	return NULL;
 
   510 }
 
   609 }
 
   511 
   610 
   512 void *fill_candidate_datatypes_c::visit(single_byte_character_string_c *symbol) {
 
   611 void *fill_candidate_datatypes_c::visit(single_byte_character_string_c *symbol) {
 
   513 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::string_type_name, &search_constant_type_c::safestring_type_name);
 
   612 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::string_type_name, &search_constant_type_c::safestring_type_name);
 
  1322  * details (e.g. how to round and truncate numbers) as defined in IEC 61131-3, we will leave this to the future.
 
  1421  * details (e.g. how to round and truncate numbers) as defined in IEC 61131-3, we will leave this to the future.
 
  1323  * Also, the question will arise if we should also replace calls to standard
 
  1422  * Also, the question will arise if we should also replace calls to standard
 
  1324  * functions if the input parameters are all literals (e.g. ADD(42, 42)). This
 
  1423  * functions if the input parameters are all literals (e.g. ADD(42, 42)). This
 
  1325  * means this class will be more difficult than it appears at first.
 
  1424  * means this class will be more difficult than it appears at first.
 
  1326  */
 
  1425  */
 
  1327 void *fill_candidate_datatypes_c::visit(  add_expression_c *symbol) {return handle_binary_expression(widen_ADD_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1426 void *fill_candidate_datatypes_c::visit(  add_expression_c *symbol) {
 
       
  1427 	void *ret = handle_binary_expression(widen_ADD_table,  symbol, symbol->l_exp, symbol->r_exp);
 
       
  1428 	remove_incompatible_datatypes(symbol);
 
       
  1429 	return ret;
 
       
  1430 }
 
  1328 void *fill_candidate_datatypes_c::visit(  sub_expression_c *symbol) {return handle_binary_expression(widen_SUB_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1431 void *fill_candidate_datatypes_c::visit(  sub_expression_c *symbol) {return handle_binary_expression(widen_SUB_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1329 void *fill_candidate_datatypes_c::visit(  mul_expression_c *symbol) {return handle_binary_expression(widen_MUL_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1432 void *fill_candidate_datatypes_c::visit(  mul_expression_c *symbol) {return handle_binary_expression(widen_MUL_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1330 void *fill_candidate_datatypes_c::visit(  div_expression_c *symbol) {return handle_binary_expression(widen_DIV_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1433 void *fill_candidate_datatypes_c::visit(  div_expression_c *symbol) {return handle_binary_expression(widen_DIV_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1331 void *fill_candidate_datatypes_c::visit(  mod_expression_c *symbol) {return handle_binary_expression(widen_MOD_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1434 void *fill_candidate_datatypes_c::visit(  mod_expression_c *symbol) {return handle_binary_expression(widen_MOD_table,  symbol, symbol->l_exp, symbol->r_exp);}
 
  1332 void *fill_candidate_datatypes_c::visit(power_expression_c *symbol) {return handle_binary_expression(widen_EXPT_table, symbol, symbol->l_exp, symbol->r_exp);}
 
  1435 void *fill_candidate_datatypes_c::visit(power_expression_c *symbol) {return handle_binary_expression(widen_EXPT_table, symbol, symbol->l_exp, symbol->r_exp);}
matiec