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 472 d26759a2274a
parent 470 d2cd05c5e01a
child 473 933d6c204607
equal deleted inserted replaced
471:da650a87662d 472:d26759a2274a 
    74   symbol->candidate_datatypes.push_back(datatype);
 
    74   symbol->candidate_datatypes.push_back(datatype);
 
    75   return true;
 
    75   return true;
 
    76 }
 
    76 }
 
    77     
    77     
    78     
    78     
    79     
    79 bool fill_candidate_datatypes_c::add_2datatypes_to_candidate_list(symbol_c *symbol, symbol_c *datatype1, symbol_c *datatype2) {
 
       
    80   add_datatype_to_candidate_list(symbol, datatype1);
 
       
    81   add_datatype_to_candidate_list(symbol, datatype2);
 
       
    82   return true;
 
       
    83 }
 
    80     
    84     
    81 
    85 
    82 /* returns true if compatible function/FB invocation, otherwise returns false */
 
    86 /* returns true if compatible function/FB invocation, otherwise returns false */
 
    83 /* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */
 
    87 /* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */
 
    84 /*
 
    88 /*
 
   320 /* B 1.2 - Constants */
 
   324 /* B 1.2 - Constants */
 
   321 /*********************/
 
   325 /*********************/
 
   322 /******************************/
 
   326 /******************************/
 
   323 /* B 1.2.1 - Numeric Literals */
 
   327 /* B 1.2.1 - Numeric Literals */
 
   324 /******************************/
 
   328 /******************************/
 
       
   329 #define sizeoftype(symbol) get_sizeof_datatype_c::getsize(symbol)
 
       
   330 
       
   331 void *fill_candidate_datatypes_c::handle_any_integer(symbol_c *symbol) {
 
       
   332 	int calc_size;
 
       
   333 
       
   334 	calc_size = sizeoftype(symbol);
 
       
   335 	if (calc_size <= sizeoftype(&search_constant_type_c::bool_type_name))
 
       
   336 	        add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
       
   337 	if (calc_size <= sizeoftype(&search_constant_type_c::byte_type_name))
 
       
   338 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::byte_type_name, &search_constant_type_c::safebyte_type_name);
 
       
   339 	if (calc_size <= sizeoftype(&search_constant_type_c::word_type_name))
 
       
   340 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::word_type_name, &search_constant_type_c::safeword_type_name);
 
       
   341 	if (calc_size <= sizeoftype(&search_constant_type_c::dword_type_name))
 
       
   342 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dword_type_name, &search_constant_type_c::safedword_type_name);
 
       
   343 	if (calc_size <= sizeoftype(&search_constant_type_c::lword_type_name))
 
       
   344 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lword_type_name, &search_constant_type_c::safelword_type_name);
 
       
   345 
       
   346 	if (calc_size < sizeoftype(&search_constant_type_c::sint_type_name))
 
       
   347 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::sint_type_name, &search_constant_type_c::safesint_type_name);
 
       
   348 	if (calc_size < sizeoftype(&search_constant_type_c::int_type_name))
 
       
   349 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::int_type_name, &search_constant_type_c::safeint_type_name);
 
       
   350 	if (calc_size < sizeoftype(&search_constant_type_c::dint_type_name))
 
       
   351 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dint_type_name, &search_constant_type_c::safedint_type_name);
 
       
   352 	if (calc_size < sizeoftype(&search_constant_type_c::lint_type_name))
 
       
   353 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lint_type_name, &search_constant_type_c::safelint_type_name);
 
       
   354 	if (calc_size <= sizeoftype(&search_constant_type_c::usint_type_name))
 
       
   355 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::usint_type_name, &search_constant_type_c::safeusint_type_name);
 
       
   356 	if (calc_size <= sizeoftype(&search_constant_type_c::uint_type_name))
 
       
   357 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::uint_type_name, &search_constant_type_c::safeuint_type_name);
 
       
   358 	if (calc_size <= sizeoftype(&search_constant_type_c::udint_type_name))
 
       
   359 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::udint_type_name, &search_constant_type_c::safeudint_type_name);
 
       
   360 	if (calc_size <= sizeoftype(&search_constant_type_c::ulint_type_name))
 
       
   361 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::ulint_type_name, &search_constant_type_c::safeulint_type_name);
 
       
   362 	return NULL;
 
       
   363 }
 
       
   364 
       
   365 
       
   366 
       
   367 
   325 void *fill_candidate_datatypes_c::visit(real_c *symbol) {
 
   368 void *fill_candidate_datatypes_c::visit(real_c *symbol) {
 
   326 	int calc_size;
 
   369 	int calc_size;
 
   327 
   370 
   328 	calc_size = sizeoftype(symbol);
 
   371 	calc_size = sizeoftype(symbol);
 
   329 	if (calc_size <= sizeoftype(&search_constant_type_c::real_type_name))
 
   372 	if (calc_size <= sizeoftype(&search_constant_type_c::real_type_name))
 
   330 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::real_type_name);
 
   373 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::real_type_name,  &search_constant_type_c::safereal_type_name);
 
   331 	if (calc_size <= sizeoftype(&search_constant_type_c::lreal_type_name))
 
   374 	if (calc_size <= sizeoftype(&search_constant_type_c::lreal_type_name))
 
   332 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lreal_type_name);
 
   375 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lreal_type_name, &search_constant_type_c::safelreal_type_name);
 
   333 	if (debug) std::cout << "ANY_REAL [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   376 	if (debug) std::cout << "ANY_REAL [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   334 	return NULL;
 
   377 	return NULL;
 
   335 }
 
   378 }
 
   336 
   379 
       
   380 
       
   381 
   337 void *fill_candidate_datatypes_c::visit(integer_c *symbol) {
 
   382 void *fill_candidate_datatypes_c::visit(integer_c *symbol) {
 
       
   383 	handle_any_integer(symbol);
 
       
   384 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
       
   385 	return NULL;
 
       
   386 }
 
       
   387 
       
   388 
       
   389 void *fill_candidate_datatypes_c::visit(neg_real_c *symbol) {
 
   338 	int calc_size;
 
   390 	int calc_size;
 
   339 
   391 
   340 	calc_size = sizeoftype(symbol);
 
   392 	calc_size = sizeoftype(symbol);
 
   341 	if (calc_size <= sizeoftype(&search_constant_type_c::bool_type_name))
 
   393 	if (calc_size <= sizeoftype(&search_constant_type_c::real_type_name))
 
   342 	        add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);
 
   394 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::real_type_name, &search_constant_type_c::safereal_type_name);
 
   343 	if (calc_size <= sizeoftype(&search_constant_type_c::byte_type_name))
 
   395 	if (calc_size <= sizeoftype(&search_constant_type_c::lreal_type_name))
 
   344 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::byte_type_name);
 
   396 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lreal_type_name, &search_constant_type_c::safelreal_type_name);
 
   345 	if (calc_size <= sizeoftype(&search_constant_type_c::word_type_name))
 
       
   346 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::word_type_name);
 
       
   347 	if (calc_size <= sizeoftype(&search_constant_type_c::dword_type_name))
 
       
   348 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dword_type_name);
 
       
   349 	if (calc_size <= sizeoftype(&search_constant_type_c::lword_type_name))
 
       
   350 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lword_type_name);
 
       
   351 
       
   352 	if (calc_size < sizeoftype(&search_constant_type_c::sint_type_name))
 
       
   353 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::sint_type_name);
 
       
   354 	if (calc_size < sizeoftype(&search_constant_type_c::int_type_name))
 
       
   355 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::int_type_name);
 
       
   356 	if (calc_size < sizeoftype(&search_constant_type_c::dint_type_name))
 
       
   357 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dint_type_name);
 
       
   358 	if (calc_size < sizeoftype(&search_constant_type_c::lint_type_name))
 
       
   359 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lint_type_name);
 
       
   360 	if (calc_size <= sizeoftype(&search_constant_type_c::usint_type_name))
 
       
   361 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::usint_type_name);
 
       
   362 	if (calc_size <= sizeoftype(&search_constant_type_c::uint_type_name))
 
       
   363 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::uint_type_name);
 
       
   364 	if (calc_size <= sizeoftype(&search_constant_type_c::udint_type_name))
 
       
   365 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::udint_type_name);
 
       
   366 	if (calc_size <= sizeoftype(&search_constant_type_c::ulint_type_name))
 
       
   367 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::ulint_type_name);
 
       
   368 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
       
   369 	return NULL;
 
       
   370 }
 
       
   371 
       
   372 void *fill_candidate_datatypes_c::visit(neg_real_c *symbol) {
 
       
   373 	if (sizeoftype(symbol) <= sizeoftype(&search_constant_type_c::real_type_name))
 
       
   374 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::real_type_name);
 
       
   375 	add_datatype_to_candidate_list(symbol, &search_constant_type_c::lreal_type_name);
 
       
   376 	if (debug) std::cout << "neg ANY_REAL [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   397 	if (debug) std::cout << "neg ANY_REAL [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   377 	return NULL;
 
   398 	return NULL;
 
   378 }
 
   399 }
 
       
   400 
   379 
   401 
   380 void *fill_candidate_datatypes_c::visit(neg_integer_c *symbol) {
 
   402 void *fill_candidate_datatypes_c::visit(neg_integer_c *symbol) {
 
   381 	int calc_size;
 
   403 	int calc_size;
 
   382 
   404 
   383 	calc_size = sizeoftype(symbol);
 
   405 	calc_size = sizeoftype(symbol);
 
   384 	if (calc_size <= sizeoftype(&search_constant_type_c::int_type_name))
 
   406 	if (calc_size <= sizeoftype(&search_constant_type_c::int_type_name))
 
   385 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::int_type_name);
 
   407 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::int_type_name, &search_constant_type_c::safeint_type_name);
 
   386 	if (calc_size <= sizeoftype(&search_constant_type_c::sint_type_name))
 
   408 	if (calc_size <= sizeoftype(&search_constant_type_c::sint_type_name))
 
   387 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::sint_type_name);
 
   409 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::sint_type_name, &search_constant_type_c::safesint_type_name);
 
   388 	if (calc_size <= sizeoftype(&search_constant_type_c::dint_type_name))
 
   410 	if (calc_size <= sizeoftype(&search_constant_type_c::dint_type_name))
 
   389 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dint_type_name);
 
   411 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::dint_type_name, &search_constant_type_c::safedint_type_name);
 
   390 	if (calc_size <= sizeoftype(&search_constant_type_c::lint_type_name))
 
   412 	if (calc_size <= sizeoftype(&search_constant_type_c::lint_type_name))
 
   391 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lint_type_name);
 
   413 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::lint_type_name, &search_constant_type_c::safelint_type_name);
 
   392 	if (debug) std::cout << "neg ANY_INT [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   414 	if (debug) std::cout << "neg ANY_INT [" << symbol->candidate_datatypes.size() << "]" << std::endl;
 
   393 	return NULL;
 
   415 	return NULL;
 
   394 }
 
   416 }
 
   395 
   417 
       
   418 
   396 void *fill_candidate_datatypes_c::visit(binary_integer_c *symbol) {
 
   419 void *fill_candidate_datatypes_c::visit(binary_integer_c *symbol) {
 
   397 	int calc_size;
 
   420 	handle_any_integer(symbol);
 
   398 
       
   399 	calc_size = sizeoftype(symbol);
 
       
   400 	if (calc_size <= sizeoftype(&search_constant_type_c::bool_type_name))
 
       
   401 	        add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);
 
       
   402 	if (calc_size <= sizeoftype(&search_constant_type_c::byte_type_name))
 
       
   403 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::byte_type_name);
 
       
   404 	if (calc_size <= sizeoftype(&search_constant_type_c::word_type_name))
 
       
   405 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::word_type_name);
 
       
   406 	if (calc_size <= sizeoftype(&search_constant_type_c::dword_type_name))
 
       
   407 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dword_type_name);
 
       
   408 	if (calc_size <= sizeoftype(&search_constant_type_c::lword_type_name))
 
       
   409 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lword_type_name);
 
       
   410 	
       
   411 	if (calc_size < sizeoftype(&search_constant_type_c::sint_type_name))
 
       
   412 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::sint_type_name);
 
       
   413 	if (calc_size < sizeoftype(&search_constant_type_c::int_type_name))
 
       
   414 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::int_type_name);
 
       
   415 	if (calc_size < sizeoftype(&search_constant_type_c::dint_type_name))
 
       
   416 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dint_type_name);
 
       
   417 	if (calc_size < sizeoftype(&search_constant_type_c::lint_type_name))
 
       
   418 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lint_type_name);
 
       
   419 	if (calc_size <= sizeoftype(&search_constant_type_c::usint_type_name))
 
       
   420 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::usint_type_name);
 
       
   421 	if (calc_size <= sizeoftype(&search_constant_type_c::uint_type_name))
 
       
   422 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::uint_type_name);
 
       
   423 	if (calc_size <= sizeoftype(&search_constant_type_c::udint_type_name))
 
       
   424 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::udint_type_name);
 
       
   425 	if (calc_size <= sizeoftype(&search_constant_type_c::ulint_type_name))
 
       
   426 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::ulint_type_name);
 
       
   427 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
   421 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
   428 	return NULL;
 
   422 	return NULL;
 
   429 }
 
   423 }
 
   430 
   424 
       
   425 
       
   426 
   431 void *fill_candidate_datatypes_c::visit(octal_integer_c *symbol) {
 
   427 void *fill_candidate_datatypes_c::visit(octal_integer_c *symbol) {
 
   432 	int calc_size;
 
   428 	handle_any_integer(symbol);
 
   433 
       
   434 	calc_size = sizeoftype(symbol);
 
       
   435 	if (calc_size <= sizeoftype(&search_constant_type_c::bool_type_name))
 
       
   436 	        add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);
 
       
   437 	if (calc_size <= sizeoftype(&search_constant_type_c::byte_type_name))
 
       
   438 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::byte_type_name);
 
       
   439 	if (calc_size <= sizeoftype(&search_constant_type_c::word_type_name))
 
       
   440 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::word_type_name);
 
       
   441 	if (calc_size <= sizeoftype(&search_constant_type_c::dword_type_name))
 
       
   442 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dword_type_name);
 
       
   443 	if (calc_size <= sizeoftype(&search_constant_type_c::lword_type_name))
 
       
   444 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lword_type_name);
 
       
   445 
       
   446 	if (calc_size < sizeoftype(&search_constant_type_c::sint_type_name))
 
       
   447 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::sint_type_name);
 
       
   448 	if (calc_size < sizeoftype(&search_constant_type_c::int_type_name))
 
       
   449 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::int_type_name);
 
       
   450 	if (calc_size < sizeoftype(&search_constant_type_c::dint_type_name))
 
       
   451 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dint_type_name);
 
       
   452 	if (calc_size < sizeoftype(&search_constant_type_c::lint_type_name))
 
       
   453 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lint_type_name);
 
       
   454 	if (calc_size <= sizeoftype(&search_constant_type_c::usint_type_name))
 
       
   455 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::usint_type_name);
 
       
   456 	if (calc_size <= sizeoftype(&search_constant_type_c::uint_type_name))
 
       
   457 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::uint_type_name);
 
       
   458 	if (calc_size <= sizeoftype(&search_constant_type_c::udint_type_name))
 
       
   459 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::udint_type_name);
 
       
   460 	if (calc_size <= sizeoftype(&search_constant_type_c::ulint_type_name))
 
       
   461 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::ulint_type_name);
 
       
   462 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
   429 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
   463 	return NULL;
 
   430 	return NULL;
 
   464 }
 
   431 }
 
   465 
   432 
       
   433 
       
   434 
   466 void *fill_candidate_datatypes_c::visit(hex_integer_c *symbol) {
 
   435 void *fill_candidate_datatypes_c::visit(hex_integer_c *symbol) {
 
   467 	int calc_size;
 
   436 	handle_any_integer(symbol);
 
   468 
       
   469 	calc_size = sizeoftype(symbol);
 
       
   470 	if (calc_size <= sizeoftype(&search_constant_type_c::bool_type_name))
 
       
   471 	        add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);
 
       
   472 	if (calc_size <= sizeoftype(&search_constant_type_c::byte_type_name))
 
       
   473 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::byte_type_name);
 
       
   474 	if (calc_size <= sizeoftype(&search_constant_type_c::word_type_name))
 
       
   475 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::word_type_name);
 
       
   476 	if (calc_size <= sizeoftype(&search_constant_type_c::dword_type_name))
 
       
   477 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dword_type_name);
 
       
   478 	if (calc_size <= sizeoftype(&search_constant_type_c::lword_type_name))
 
       
   479 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lword_type_name);
 
       
   480 
       
   481 	if (calc_size < sizeoftype(&search_constant_type_c::sint_type_name))
 
       
   482 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::sint_type_name);
 
       
   483 	if (calc_size < sizeoftype(&search_constant_type_c::int_type_name))
 
       
   484 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::int_type_name);
 
       
   485 	if (calc_size < sizeoftype(&search_constant_type_c::dint_type_name))
 
       
   486 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::dint_type_name);
 
       
   487 	if (calc_size < sizeoftype(&search_constant_type_c::lint_type_name))
 
       
   488 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::lint_type_name);
 
       
   489 	if (calc_size <= sizeoftype(&search_constant_type_c::usint_type_name))
 
       
   490 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::usint_type_name);
 
       
   491 	if (calc_size <= sizeoftype(&search_constant_type_c::uint_type_name))
 
       
   492 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::uint_type_name);
 
       
   493 	if (calc_size <= sizeoftype(&search_constant_type_c::udint_type_name))
 
       
   494 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::udint_type_name);
 
       
   495 	if (calc_size <= sizeoftype(&search_constant_type_c::ulint_type_name))
 
       
   496 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::ulint_type_name);
 
       
   497 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
   437 	if (debug) std::cout << "ANY_INT [" << symbol->candidate_datatypes.size()<< "]" << std::endl;
 
   498 	return NULL;
 
   438 	return NULL;
 
   499 }
 
   439 }
 
   500 
   440 
       
   441 
   501 // SYM_REF2(integer_literal_c, type, value)
 
   442 // SYM_REF2(integer_literal_c, type, value)
 
       
   443 /*
 
       
   444  * integer_literal:
 
       
   445  *   integer_type_name '#' signed_integer
 
       
   446  * | integer_type_name '#' binary_integer
 
       
   447  * | integer_type_name '#' octal_integer
 
       
   448  * | integer_type_name '#' hex_integer
 
       
   449  */
 
   502 void *fill_candidate_datatypes_c::visit(integer_literal_c *symbol) {
 
   450 void *fill_candidate_datatypes_c::visit(integer_literal_c *symbol) {
 
   503 	symbol->value->accept(*this);
 
   451 	symbol->value->accept(*this);
 
   504 	if (search_in_candidate_datatype_list(symbol->type, symbol->value->candidate_datatypes) >= 0)
 
   452 	if (search_in_candidate_datatype_list(symbol->type, symbol->value->candidate_datatypes) >= 0)
 
   505 		add_datatype_to_candidate_list(symbol, symbol->type);
 
   453 		add_datatype_to_candidate_list(symbol, symbol->type);
 
   506 	if (debug) std::cout << "INT_LITERAL [" << symbol->candidate_datatypes.size() << "]\n";
 
   454 	if (debug) std::cout << "INT_LITERAL [" << symbol->candidate_datatypes.size() << "]\n";
 
   530 		 */
 
   478 		 */
 
   531 		add_datatype_to_candidate_list(symbol, symbol->type);
 
   479 		add_datatype_to_candidate_list(symbol, symbol->type);
 
   532 	else {
 
   480 	else {
 
   533 		/* Then only a literal TRUE or FALSE was given! */
 
   481 		/* Then only a literal TRUE or FALSE was given! */
 
   534 		/* In this case, symbol->type will be NULL!     */
 
   482 		/* In this case, symbol->type will be NULL!     */
 
   535 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);
 
   483 		add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
   536 		add_datatype_to_candidate_list(symbol, &search_constant_type_c::safebool_type_name);
 
       
   537 	}
 
   484 	}
 
   538 	return NULL;
 
   485 	return NULL;
 
   539 }
 
   486 }
 
   540 
   487 
   541 void *fill_candidate_datatypes_c::visit(boolean_true_c *symbol) {
 
   488 void *fill_candidate_datatypes_c::visit(boolean_true_c *symbol) {
 
   542 	add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);
 
   489 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
   543 	add_datatype_to_candidate_list(symbol, &search_constant_type_c::safebool_type_name);
 
       
   544 	return NULL;
 
   490 	return NULL;
 
   545 }
 
   491 }
 
   546 
   492 
   547 void *fill_candidate_datatypes_c::visit(boolean_false_c *symbol) {
 
   493 void *fill_candidate_datatypes_c::visit(boolean_false_c *symbol) {
 
   548 	add_datatype_to_candidate_list(symbol, &search_constant_type_c::bool_type_name);
 
   494 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::bool_type_name, &search_constant_type_c::safebool_type_name);
 
   549 	add_datatype_to_candidate_list(symbol, &search_constant_type_c::safebool_type_name);
 
       
   550 	return NULL;
 
   495 	return NULL;
 
   551 }
 
   496 }
 
   552 
   497 
   553 /*******************************/
 
   498 /*******************************/
 
   554 /* B.1.2.2   Character Strings */
 
   499 /* B.1.2.2   Character Strings */
 
   555 /*******************************/
 
   500 /*******************************/
 
   556 void *fill_candidate_datatypes_c::visit(double_byte_character_string_c *symbol) {
 
   501 void *fill_candidate_datatypes_c::visit(double_byte_character_string_c *symbol) {
 
   557 	add_datatype_to_candidate_list(symbol, &search_constant_type_c::wstring_type_name);
 
   502 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::wstring_type_name, &search_constant_type_c::safewstring_type_name);
 
   558 	return NULL;
 
   503 	return NULL;
 
   559 }
 
   504 }
 
   560 
   505 
   561 void *fill_candidate_datatypes_c::visit(single_byte_character_string_c *symbol) {
 
   506 void *fill_candidate_datatypes_c::visit(single_byte_character_string_c *symbol) {
 
   562 	add_datatype_to_candidate_list(symbol, &search_constant_type_c::string_type_name);
 
   507 	add_2datatypes_to_candidate_list(symbol, &search_constant_type_c::string_type_name, &search_constant_type_c::safestring_type_name);
 
   563 	return NULL;
 
   508 	return NULL;
 
   564 }
 
   509 }
 
   565 
   510 
   566 /***************************/
 
   511 /***************************/
 
   567 /* B 1.2.3 - Time Literals */
 
   512 /* B 1.2.3 - Time Literals */
 
   570 /* B 1.2.3.1 - Duration */
 
   515 /* B 1.2.3.1 - Duration */
 
   571 /************************/
 
   516 /************************/
 
   572 void *fill_candidate_datatypes_c::visit(duration_c *symbol) {
 
   517 void *fill_candidate_datatypes_c::visit(duration_c *symbol) {
 
   573 	/* TODO: check whether the literal follows the rules specified in section '2.2.3.1 Duration' of the standard! */
 
   518 	/* TODO: check whether the literal follows the rules specified in section '2.2.3.1 Duration' of the standard! */
 
   574 	
   519 	
   575 	/* Either of the following two lines is correct. Each of them will have advantages and drawbacks during compiler debugging. Use whichever suits you best... */
 
   520 	add_datatype_to_candidate_list(symbol, symbol->type_name);
 
   576 	add_datatype_to_candidate_list(symbol, &search_constant_type_c::time_type_name);
 
       
   577 // 	symbol->candidate_datatypes.push_back(symbol->type_name);
 
       
   578 	if (debug) std::cout << "TIME_LITERAL [" << symbol->candidate_datatypes.size() << "]\n";
 
   521 	if (debug) std::cout << "TIME_LITERAL [" << symbol->candidate_datatypes.size() << "]\n";
 
   579 	return NULL;
 
   522 	return NULL;
 
   580 }
 
   523 }
 
   581 
   524 
   582 /************************************/
 
   525 /************************************/
 
  1535 }
 
  1478 }
 
  1536 
  1479 
  1537 void *fill_candidate_datatypes_c::visit(CALC_operator_c *symbol) {
 
  1480 void *fill_candidate_datatypes_c::visit(CALC_operator_c *symbol) {
 
  1538 	if (NULL == prev_il_instruction) return NULL;
 
  1481 	if (NULL == prev_il_instruction) return NULL;
 
  1539 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1482 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1540 		if (is_type(prev_il_instruction->candidate_datatypes[i], bool_type_name_c))
 
  1483 		if (is_ANY_BOOL_compatible(prev_il_instruction->candidate_datatypes[i]))
 
  1541 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1484 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1542 	}
 
  1485 	}
 
  1543 	if (debug) std::cout <<  "CALC [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1486 	if (debug) std::cout <<  "CALC [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1544 	return NULL;
 
  1487 	return NULL;
 
  1545 }
 
  1488 }
 
  1546 
  1489 
  1547 void *fill_candidate_datatypes_c::visit(CALCN_operator_c *symbol) {
 
  1490 void *fill_candidate_datatypes_c::visit(CALCN_operator_c *symbol) {
 
  1548 	if (NULL == prev_il_instruction) return NULL;
 
  1491 	if (NULL == prev_il_instruction) return NULL;
 
  1549 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1492 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1550 		if (is_type(prev_il_instruction->candidate_datatypes[i], bool_type_name_c))
 
  1493 		if (is_ANY_BOOL_compatible(prev_il_instruction->candidate_datatypes[i]))
 
  1551 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1494 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1552 	}
 
  1495 	}
 
  1553 	if (debug) std::cout <<  "CALCN [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1496 	if (debug) std::cout <<  "CALCN [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1554 	return NULL;
 
  1497 	return NULL;
 
  1555 }
 
  1498 }
 
  1565 }
 
  1508 }
 
  1566 
  1509 
  1567 void *fill_candidate_datatypes_c::visit(RETC_operator_c *symbol) {
 
  1510 void *fill_candidate_datatypes_c::visit(RETC_operator_c *symbol) {
 
  1568 	if (NULL == prev_il_instruction) return NULL;
 
  1511 	if (NULL == prev_il_instruction) return NULL;
 
  1569 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1512 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1570 		if (is_type(prev_il_instruction->candidate_datatypes[i], bool_type_name_c))
 
  1513 		if (is_ANY_BOOL_compatible(prev_il_instruction->candidate_datatypes[i]))
 
  1571 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1514 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1572 	}
 
  1515 	}
 
  1573 	if (debug) std::cout <<  "RETC [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1516 	if (debug) std::cout <<  "RETC [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1574 	return NULL;
 
  1517 	return NULL;
 
  1575 }
 
  1518 }
 
  1576 
  1519 
  1577 void *fill_candidate_datatypes_c::visit(RETCN_operator_c *symbol) {
 
  1520 void *fill_candidate_datatypes_c::visit(RETCN_operator_c *symbol) {
 
  1578 	if (NULL == prev_il_instruction) return NULL;
 
  1521 	if (NULL == prev_il_instruction) return NULL;
 
  1579 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1522 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1580 		if (is_type(prev_il_instruction->candidate_datatypes[i], bool_type_name_c))
 
  1523 		if (is_ANY_BOOL_compatible(prev_il_instruction->candidate_datatypes[i]))
 
  1581 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1524 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1582 	}
 
  1525 	}
 
  1583 	if (debug) std::cout <<  "RETCN [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1526 	if (debug) std::cout <<  "RETCN [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1584 	return NULL;
 
  1527 	return NULL;
 
  1585 }
 
  1528 }
 
  1594 	return NULL;
 
  1537 	return NULL;
 
  1595 }
 
  1538 }
 
  1596 
  1539 
  1597 void *fill_candidate_datatypes_c::visit(JMPC_operator_c *symbol) {
 
  1540 void *fill_candidate_datatypes_c::visit(JMPC_operator_c *symbol) {
 
  1598 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1541 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1599 		if (is_type(prev_il_instruction->candidate_datatypes[i], bool_type_name_c))
 
  1542 		if (is_ANY_BOOL_compatible(prev_il_instruction->candidate_datatypes[i]))
 
  1600 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1543 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1601 	}
 
  1544 	}
 
  1602 	if (debug) std::cout <<  "JMPC [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1545 	if (debug) std::cout <<  "JMPC [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1603 	return NULL;
 
  1546 	return NULL;
 
  1604 }
 
  1547 }
 
  1605 
  1548 
  1606 void *fill_candidate_datatypes_c::visit(JMPCN_operator_c *symbol) {
 
  1549 void *fill_candidate_datatypes_c::visit(JMPCN_operator_c *symbol) {
 
  1607 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1550 	for (unsigned int i = 0; i < prev_il_instruction->candidate_datatypes.size(); i++) {
 
  1608 		if (is_type(prev_il_instruction->candidate_datatypes[i], bool_type_name_c))
 
  1551 		if (is_ANY_BOOL_compatible(prev_il_instruction->candidate_datatypes[i]))
 
  1609 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1552 			add_datatype_to_candidate_list(symbol, prev_il_instruction->candidate_datatypes[i]);
 
  1610 	}
 
  1553 	}
 
  1611 	if (debug) std::cout <<  "JMPCN [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1554 	if (debug) std::cout <<  "JMPCN [" << prev_il_instruction->candidate_datatypes.size() << "] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 
  1612 	return NULL;
 
  1555 	return NULL;
 
  1613 }
 
  1556 }
matiec