1 

     2 /****

     3  * IEC 61131-3 standard function lib

     4  * generated code, do not edit by hand

     5  */

     6 switch(current_function_type){

     7 

     8 /****

     9  *REAL_TO_REAL

    10  */

    11 	case function_real_to_real :

    12 	{

    13 		symbol_c *last_type_symbol = NULL;

    14 

    15 		{

    16 			identifier_c param_name("IN");

    17 			/* Get the value from a foo(<param_name> = <param_value>) style call */

    18 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

    19 			

    20 			/* Get the value from a foo(<param_value>) style call */

    21 			if (IN_param_value == NULL)

    22 			  IN_param_value = function_call_param_iterator.next();

    23 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

    24 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

    25 			

    26 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

    27 			{

    28 		

    29 				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

    30 				return return_type_symbol;

    31 				

    32 			}

    33 			

    34 			ERROR;

    35 		}

    36 		

    37 	}/*function_real_to_real*/

    38 	break;

    39 

    40 /****

    41  *REAL_TO_SINT

    42  */

    43 	case function_real_to_sint :

    44 	{

    45 		symbol_c *last_type_symbol = NULL;

    46 

    47 		{

    48 			identifier_c param_name("IN");

    49 			/* Get the value from a foo(<param_name> = <param_value>) style call */

    50 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

    51 			

    52 			/* Get the value from a foo(<param_value>) style call */

    53 			if (IN_param_value == NULL)

    54 			  IN_param_value = function_call_param_iterator.next();

    55 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

    56 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

    57 			

    58 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

    59 			{

    60 		

    61 				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    62 				return return_type_symbol;

    63 				

    64 			}

    65 			

    66 			ERROR;

    67 		}

    68 		

    69 	}/*function_real_to_sint*/

    70 	break;

    71 

    72 /****

    73  *REAL_TO_LINT

    74  */

    75 	case function_real_to_lint :

    76 	{

    77 		symbol_c *last_type_symbol = NULL;

    78 

    79 		{

    80 			identifier_c param_name("IN");

    81 			/* Get the value from a foo(<param_name> = <param_value>) style call */

    82 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

    83 			

    84 			/* Get the value from a foo(<param_value>) style call */

    85 			if (IN_param_value == NULL)

    86 			  IN_param_value = function_call_param_iterator.next();

    87 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

    88 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

    89 			

    90 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

    91 			{

    92 		

    93 				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

    94 				return return_type_symbol;

    95 				

    96 			}

    97 			

    98 			ERROR;

    99 		}

   100 		

   101 	}/*function_real_to_lint*/

   102 	break;

   103 

   104 /****

   105  *REAL_TO_DINT

   106  */

   107 	case function_real_to_dint :

   108 	{

   109 		symbol_c *last_type_symbol = NULL;

   110 

   111 		{

   112 			identifier_c param_name("IN");

   113 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   114 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   115 			

   116 			/* Get the value from a foo(<param_value>) style call */

   117 			if (IN_param_value == NULL)

   118 			  IN_param_value = function_call_param_iterator.next();

   119 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   120 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   121 			

   122 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   123 			{

   124 		

   125 				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   126 				return return_type_symbol;

   127 				

   128 			}

   129 			

   130 			ERROR;

   131 		}

   132 		

   133 	}/*function_real_to_dint*/

   134 	break;

   135 

   136 /****

   137  *REAL_TO_DATE

   138  */

   139 	case function_real_to_date :

   140 	{

   141 		symbol_c *last_type_symbol = NULL;

   142 

   143 		{

   144 			identifier_c param_name("IN");

   145 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   146 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   147 			

   148 			/* Get the value from a foo(<param_value>) style call */

   149 			if (IN_param_value == NULL)

   150 			  IN_param_value = function_call_param_iterator.next();

   151 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   152 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   153 			

   154 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   155 			{

   156 		

   157 				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   158 				return return_type_symbol;

   159 				

   160 			}

   161 			

   162 			ERROR;

   163 		}

   164 		

   165 	}/*function_real_to_date*/

   166 	break;

   167 

   168 /****

   169  *REAL_TO_DWORD

   170  */

   171 	case function_real_to_dword :

   172 	{

   173 		symbol_c *last_type_symbol = NULL;

   174 

   175 		{

   176 			identifier_c param_name("IN");

   177 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   178 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   179 			

   180 			/* Get the value from a foo(<param_value>) style call */

   181 			if (IN_param_value == NULL)

   182 			  IN_param_value = function_call_param_iterator.next();

   183 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   184 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   185 			

   186 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   187 			{

   188 		

   189 				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   190 				return return_type_symbol;

   191 				

   192 			}

   193 			

   194 			ERROR;

   195 		}

   196 		

   197 	}/*function_real_to_dword*/

   198 	break;

   199 

   200 /****

   201  *REAL_TO_DT

   202  */

   203 	case function_real_to_dt :

   204 	{

   205 		symbol_c *last_type_symbol = NULL;

   206 

   207 		{

   208 			identifier_c param_name("IN");

   209 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   210 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   211 			

   212 			/* Get the value from a foo(<param_value>) style call */

   213 			if (IN_param_value == NULL)

   214 			  IN_param_value = function_call_param_iterator.next();

   215 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   216 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   217 			

   218 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   219 			{

   220 		

   221 				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   222 				return return_type_symbol;

   223 				

   224 			}

   225 			

   226 			ERROR;

   227 		}

   228 		

   229 	}/*function_real_to_dt*/

   230 	break;

   231 

   232 /****

   233  *REAL_TO_TOD

   234  */

   235 	case function_real_to_tod :

   236 	{

   237 		symbol_c *last_type_symbol = NULL;

   238 

   239 		{

   240 			identifier_c param_name("IN");

   241 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   242 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   243 			

   244 			/* Get the value from a foo(<param_value>) style call */

   245 			if (IN_param_value == NULL)

   246 			  IN_param_value = function_call_param_iterator.next();

   247 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   248 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   249 			

   250 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   251 			{

   252 		

   253 				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   254 				return return_type_symbol;

   255 				

   256 			}

   257 			

   258 			ERROR;

   259 		}

   260 		

   261 	}/*function_real_to_tod*/

   262 	break;

   263 

   264 /****

   265  *REAL_TO_UDINT

   266  */

   267 	case function_real_to_udint :

   268 	{

   269 		symbol_c *last_type_symbol = NULL;

   270 

   271 		{

   272 			identifier_c param_name("IN");

   273 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   274 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   275 			

   276 			/* Get the value from a foo(<param_value>) style call */

   277 			if (IN_param_value == NULL)

   278 			  IN_param_value = function_call_param_iterator.next();

   279 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   280 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   281 			

   282 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   283 			{

   284 		

   285 				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   286 				return return_type_symbol;

   287 				

   288 			}

   289 			

   290 			ERROR;

   291 		}

   292 		

   293 	}/*function_real_to_udint*/

   294 	break;

   295 

   296 /****

   297  *REAL_TO_WORD

   298  */

   299 	case function_real_to_word :

   300 	{

   301 		symbol_c *last_type_symbol = NULL;

   302 

   303 		{

   304 			identifier_c param_name("IN");

   305 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   306 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   307 			

   308 			/* Get the value from a foo(<param_value>) style call */

   309 			if (IN_param_value == NULL)

   310 			  IN_param_value = function_call_param_iterator.next();

   311 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   312 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   313 			

   314 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   315 			{

   316 		

   317 				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   318 				return return_type_symbol;

   319 				

   320 			}

   321 			

   322 			ERROR;

   323 		}

   324 		

   325 	}/*function_real_to_word*/

   326 	break;

   327 

   328 /****

   329  *REAL_TO_WSTRING

   330  */

   331 	case function_real_to_wstring :

   332 	{

   333 		symbol_c *last_type_symbol = NULL;

   334 

   335 		{

   336 			identifier_c param_name("IN");

   337 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   338 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   339 			

   340 			/* Get the value from a foo(<param_value>) style call */

   341 			if (IN_param_value == NULL)

   342 			  IN_param_value = function_call_param_iterator.next();

   343 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   344 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   345 			

   346 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   347 			{

   348 		

   349 				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;

   350 				return return_type_symbol;

   351 				

   352 			}

   353 			

   354 			ERROR;

   355 		}

   356 		

   357 	}/*function_real_to_wstring*/

   358 	break;

   359 

   360 /****

   361  *REAL_TO_STRING

   362  */

   363 	case function_real_to_string :

   364 	{

   365 		symbol_c *last_type_symbol = NULL;

   366 

   367 		{

   368 			identifier_c param_name("IN");

   369 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   370 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   371 			

   372 			/* Get the value from a foo(<param_value>) style call */

   373 			if (IN_param_value == NULL)

   374 			  IN_param_value = function_call_param_iterator.next();

   375 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   376 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   377 			

   378 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   379 			{

   380 		

   381 				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   382 				return return_type_symbol;

   383 				

   384 			}

   385 			

   386 			ERROR;

   387 		}

   388 		

   389 	}/*function_real_to_string*/

   390 	break;

   391 

   392 /****

   393  *REAL_TO_LWORD

   394  */

   395 	case function_real_to_lword :

   396 	{

   397 		symbol_c *last_type_symbol = NULL;

   398 

   399 		{

   400 			identifier_c param_name("IN");

   401 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   402 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   403 			

   404 			/* Get the value from a foo(<param_value>) style call */

   405 			if (IN_param_value == NULL)

   406 			  IN_param_value = function_call_param_iterator.next();

   407 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   408 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   409 			

   410 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   411 			{

   412 		

   413 				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   414 				return return_type_symbol;

   415 				

   416 			}

   417 			

   418 			ERROR;

   419 		}

   420 		

   421 	}/*function_real_to_lword*/

   422 	break;

   423 

   424 /****

   425  *REAL_TO_UINT

   426  */

   427 	case function_real_to_uint :

   428 	{

   429 		symbol_c *last_type_symbol = NULL;

   430 

   431 		{

   432 			identifier_c param_name("IN");

   433 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   434 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   435 			

   436 			/* Get the value from a foo(<param_value>) style call */

   437 			if (IN_param_value == NULL)

   438 			  IN_param_value = function_call_param_iterator.next();

   439 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   440 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   441 			

   442 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   443 			{

   444 		

   445 				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   446 				return return_type_symbol;

   447 				

   448 			}

   449 			

   450 			ERROR;

   451 		}

   452 		

   453 	}/*function_real_to_uint*/

   454 	break;

   455 

   456 /****

   457  *REAL_TO_LREAL

   458  */

   459 	case function_real_to_lreal :

   460 	{

   461 		symbol_c *last_type_symbol = NULL;

   462 

   463 		{

   464 			identifier_c param_name("IN");

   465 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   466 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   467 			

   468 			/* Get the value from a foo(<param_value>) style call */

   469 			if (IN_param_value == NULL)

   470 			  IN_param_value = function_call_param_iterator.next();

   471 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   472 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   473 			

   474 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   475 			{

   476 		

   477 				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   478 				return return_type_symbol;

   479 				

   480 			}

   481 			

   482 			ERROR;

   483 		}

   484 		

   485 	}/*function_real_to_lreal*/

   486 	break;

   487 

   488 /****

   489  *REAL_TO_BYTE

   490  */

   491 	case function_real_to_byte :

   492 	{

   493 		symbol_c *last_type_symbol = NULL;

   494 

   495 		{

   496 			identifier_c param_name("IN");

   497 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   498 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   499 			

   500 			/* Get the value from a foo(<param_value>) style call */

   501 			if (IN_param_value == NULL)

   502 			  IN_param_value = function_call_param_iterator.next();

   503 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   504 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   505 			

   506 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   507 			{

   508 		

   509 				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   510 				return return_type_symbol;

   511 				

   512 			}

   513 			

   514 			ERROR;

   515 		}

   516 		

   517 	}/*function_real_to_byte*/

   518 	break;

   519 

   520 /****

   521  *REAL_TO_USINT

   522  */

   523 	case function_real_to_usint :

   524 	{

   525 		symbol_c *last_type_symbol = NULL;

   526 

   527 		{

   528 			identifier_c param_name("IN");

   529 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   530 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   531 			

   532 			/* Get the value from a foo(<param_value>) style call */

   533 			if (IN_param_value == NULL)

   534 			  IN_param_value = function_call_param_iterator.next();

   535 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   536 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   537 			

   538 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   539 			{

   540 		

   541 				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   542 				return return_type_symbol;

   543 				

   544 			}

   545 			

   546 			ERROR;

   547 		}

   548 		

   549 	}/*function_real_to_usint*/

   550 	break;

   551 

   552 /****

   553  *REAL_TO_ULINT

   554  */

   555 	case function_real_to_ulint :

   556 	{

   557 		symbol_c *last_type_symbol = NULL;

   558 

   559 		{

   560 			identifier_c param_name("IN");

   561 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   562 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   563 			

   564 			/* Get the value from a foo(<param_value>) style call */

   565 			if (IN_param_value == NULL)

   566 			  IN_param_value = function_call_param_iterator.next();

   567 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   568 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   569 			

   570 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   571 			{

   572 		

   573 				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   574 				return return_type_symbol;

   575 				

   576 			}

   577 			

   578 			ERROR;

   579 		}

   580 		

   581 	}/*function_real_to_ulint*/

   582 	break;

   583 

   584 /****

   585  *REAL_TO_BOOL

   586  */

   587 	case function_real_to_bool :

   588 	{

   589 		symbol_c *last_type_symbol = NULL;

   590 

   591 		{

   592 			identifier_c param_name("IN");

   593 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   594 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   595 			

   596 			/* Get the value from a foo(<param_value>) style call */

   597 			if (IN_param_value == NULL)

   598 			  IN_param_value = function_call_param_iterator.next();

   599 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   600 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   601 			

   602 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   603 			{

   604 		

   605 				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   606 				return return_type_symbol;

   607 				

   608 			}

   609 			

   610 			ERROR;

   611 		}

   612 		

   613 	}/*function_real_to_bool*/

   614 	break;

   615 

   616 /****

   617  *REAL_TO_TIME

   618  */

   619 	case function_real_to_time :

   620 	{

   621 		symbol_c *last_type_symbol = NULL;

   622 

   623 		{

   624 			identifier_c param_name("IN");

   625 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   626 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   627 			

   628 			/* Get the value from a foo(<param_value>) style call */

   629 			if (IN_param_value == NULL)

   630 			  IN_param_value = function_call_param_iterator.next();

   631 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   632 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   633 			

   634 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   635 			{

   636 		

   637 				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   638 				return return_type_symbol;

   639 				

   640 			}

   641 			

   642 			ERROR;

   643 		}

   644 		

   645 	}/*function_real_to_time*/

   646 	break;

   647 

   648 /****

   649  *REAL_TO_INT

   650  */

   651 	case function_real_to_int :

   652 	{

   653 		symbol_c *last_type_symbol = NULL;

   654 

   655 		{

   656 			identifier_c param_name("IN");

   657 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   658 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   659 			

   660 			/* Get the value from a foo(<param_value>) style call */

   661 			if (IN_param_value == NULL)

   662 			  IN_param_value = function_call_param_iterator.next();

   663 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   664 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   665 			

   666 			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   667 			{

   668 		

   669 				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   670 				return return_type_symbol;

   671 				

   672 			}

   673 			

   674 			ERROR;

   675 		}

   676 		

   677 	}/*function_real_to_int*/

   678 	break;

   679 

   680 /****

   681  *SINT_TO_REAL

   682  */

   683 	case function_sint_to_real :

   684 	{

   685 		symbol_c *last_type_symbol = NULL;

   686 

   687 		{

   688 			identifier_c param_name("IN");

   689 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   690 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   691 			

   692 			/* Get the value from a foo(<param_value>) style call */

   693 			if (IN_param_value == NULL)

   694 			  IN_param_value = function_call_param_iterator.next();

   695 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   696 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   697 			

   698 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   699 			{

   700 		

   701 				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   702 				return return_type_symbol;

   703 				

   704 			}

   705 			

   706 			ERROR;

   707 		}

   708 		

   709 	}/*function_sint_to_real*/

   710 	break;

   711 

   712 /****

   713  *SINT_TO_SINT

   714  */

   715 	case function_sint_to_sint :

   716 	{

   717 		symbol_c *last_type_symbol = NULL;

   718 

   719 		{

   720 			identifier_c param_name("IN");

   721 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   722 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   723 			

   724 			/* Get the value from a foo(<param_value>) style call */

   725 			if (IN_param_value == NULL)

   726 			  IN_param_value = function_call_param_iterator.next();

   727 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   728 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   729 			

   730 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   731 			{

   732 		

   733 				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

   734 				return return_type_symbol;

   735 				

   736 			}

   737 			

   738 			ERROR;

   739 		}

   740 		

   741 	}/*function_sint_to_sint*/

   742 	break;

   743 

   744 /****

   745  *SINT_TO_LINT

   746  */

   747 	case function_sint_to_lint :

   748 	{

   749 		symbol_c *last_type_symbol = NULL;

   750 

   751 		{

   752 			identifier_c param_name("IN");

   753 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   754 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   755 			

   756 			/* Get the value from a foo(<param_value>) style call */

   757 			if (IN_param_value == NULL)

   758 			  IN_param_value = function_call_param_iterator.next();

   759 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   760 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   761 			

   762 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   763 			{

   764 		

   765 				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   766 				return return_type_symbol;

   767 				

   768 			}

   769 			

   770 			ERROR;

   771 		}

   772 		

   773 	}/*function_sint_to_lint*/

   774 	break;

   775 

   776 /****

   777  *SINT_TO_DINT

   778  */

   779 	case function_sint_to_dint :

   780 	{

   781 		symbol_c *last_type_symbol = NULL;

   782 

   783 		{

   784 			identifier_c param_name("IN");

   785 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   786 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   787 			

   788 			/* Get the value from a foo(<param_value>) style call */

   789 			if (IN_param_value == NULL)

   790 			  IN_param_value = function_call_param_iterator.next();

   791 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   792 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   793 			

   794 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   795 			{

   796 		

   797 				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   798 				return return_type_symbol;

   799 				

   800 			}

   801 			

   802 			ERROR;

   803 		}

   804 		

   805 	}/*function_sint_to_dint*/

   806 	break;

   807 

   808 /****

   809  *SINT_TO_DATE

   810  */

   811 	case function_sint_to_date :

   812 	{

   813 		symbol_c *last_type_symbol = NULL;

   814 

   815 		{

   816 			identifier_c param_name("IN");

   817 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   818 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   819 			

   820 			/* Get the value from a foo(<param_value>) style call */

   821 			if (IN_param_value == NULL)

   822 			  IN_param_value = function_call_param_iterator.next();

   823 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   824 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   825 			

   826 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   827 			{

   828 		

   829 				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   830 				return return_type_symbol;

   831 				

   832 			}

   833 			

   834 			ERROR;

   835 		}

   836 		

   837 	}/*function_sint_to_date*/

   838 	break;

   839 

   840 /****

   841  *SINT_TO_DWORD

   842  */

   843 	case function_sint_to_dword :

   844 	{

   845 		symbol_c *last_type_symbol = NULL;

   846 

   847 		{

   848 			identifier_c param_name("IN");

   849 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   850 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   851 			

   852 			/* Get the value from a foo(<param_value>) style call */

   853 			if (IN_param_value == NULL)

   854 			  IN_param_value = function_call_param_iterator.next();

   855 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   856 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   857 			

   858 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   859 			{

   860 		

   861 				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   862 				return return_type_symbol;

   863 				

   864 			}

   865 			

   866 			ERROR;

   867 		}

   868 		

   869 	}/*function_sint_to_dword*/

   870 	break;

   871 

   872 /****

   873  *SINT_TO_DT

   874  */

   875 	case function_sint_to_dt :

   876 	{

   877 		symbol_c *last_type_symbol = NULL;

   878 

   879 		{

   880 			identifier_c param_name("IN");

   881 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   882 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   883 			

   884 			/* Get the value from a foo(<param_value>) style call */

   885 			if (IN_param_value == NULL)

   886 			  IN_param_value = function_call_param_iterator.next();

   887 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   888 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   889 			

   890 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   891 			{

   892 		

   893 				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   894 				return return_type_symbol;

   895 				

   896 			}

   897 			

   898 			ERROR;

   899 		}

   900 		

   901 	}/*function_sint_to_dt*/

   902 	break;

   903 

   904 /****

   905  *SINT_TO_TOD

   906  */

   907 	case function_sint_to_tod :

   908 	{

   909 		symbol_c *last_type_symbol = NULL;

   910 

   911 		{

   912 			identifier_c param_name("IN");

   913 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   914 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   915 			

   916 			/* Get the value from a foo(<param_value>) style call */

   917 			if (IN_param_value == NULL)

   918 			  IN_param_value = function_call_param_iterator.next();

   919 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   920 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   921 			

   922 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   923 			{

   924 		

   925 				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   926 				return return_type_symbol;

   927 				

   928 			}

   929 			

   930 			ERROR;

   931 		}

   932 		

   933 	}/*function_sint_to_tod*/

   934 	break;

   935 

   936 /****

   937  *SINT_TO_UDINT

   938  */

   939 	case function_sint_to_udint :

   940 	{

   941 		symbol_c *last_type_symbol = NULL;

   942 

   943 		{

   944 			identifier_c param_name("IN");

   945 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   946 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   947 			

   948 			/* Get the value from a foo(<param_value>) style call */

   949 			if (IN_param_value == NULL)

   950 			  IN_param_value = function_call_param_iterator.next();

   951 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   952 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   953 			

   954 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   955 			{

   956 		

   957 				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   958 				return return_type_symbol;

   959 				

   960 			}

   961 			

   962 			ERROR;

   963 		}

   964 		

   965 	}/*function_sint_to_udint*/

   966 	break;

   967 

   968 /****

   969  *SINT_TO_WORD

   970  */

   971 	case function_sint_to_word :

   972 	{

   973 		symbol_c *last_type_symbol = NULL;

   974 

   975 		{

   976 			identifier_c param_name("IN");

   977 			/* Get the value from a foo(<param_name> = <param_value>) style call */

   978 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   979 			

   980 			/* Get the value from a foo(<param_value>) style call */

   981 			if (IN_param_value == NULL)

   982 			  IN_param_value = function_call_param_iterator.next();

   983 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   984 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   985 			

   986 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   987 			{

   988 		

   989 				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   990 				return return_type_symbol;

   991 				

   992 			}

   993 			

   994 			ERROR;

   995 		}

   996 		

   997 	}/*function_sint_to_word*/

   998 	break;

   999 

  1000 /****

  1001  *SINT_TO_WSTRING

  1002  */

  1003 	case function_sint_to_wstring :

  1004 	{

  1005 		symbol_c *last_type_symbol = NULL;

  1006 

  1007 		{

  1008 			identifier_c param_name("IN");

  1009 			/* Get the value from a foo(<param_name> = <param_value>) style call */

  1010 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1011 			

  1012 			/* Get the value from a foo(<param_value>) style call */

  1013 			if (IN_param_value == NULL)

  1014 			  IN_param_value = function_call_param_iterator.next();

  1015 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1016 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1017 			

  1018 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

  1019 			{

  1020 		

  1021 				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;

  1022 				return return_type_symbol;

  1023 				

  1024 			}

  1025 			

  1026 			ERROR;

  1027 		}

  1028 		

  1029 	}/*function_sint_to_wstring*/

  1030 	break;

  1031 

  1032 /****

  1033  *SINT_TO_STRING

  1034  */

  1035 	case function_sint_to_string :

  1036 	{

  1037 		symbol_c *last_type_symbol = NULL;

  1038 

  1039 		{

  1040 			identifier_c param_name("IN");

  1041 			/* Get the value from a foo(<param_name> = <param_value>) style call */

  1042 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1043 			

  1044 			/* Get the value from a foo(<param_value>) style call */

  1045 			if (IN_param_value == NULL)

  1046 			  IN_param_value = function_call_param_iterator.next();

  1047 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1048 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1049 			

  1050 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

  1051 			{

  1052 		

  1053 				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

  1054 				return return_type_symbol;

  1055 				

  1056 			}

  1057 			

  1058 			ERROR;

  1059 		}

  1060 		

  1061 	}/*function_sint_to_string*/

  1062 	break;

  1063 

  1064 /****

  1065  *SINT_TO_LWORD

  1066  */

  1067 	case function_sint_to_lword :

  1068 	{

  1069 		symbol_c *last_type_symbol = NULL;

  1070 

  1071 		{

  1072 			identifier_c param_name("IN");

  1073 			/* Get the value from a foo(<param_name> = <param_value>) style call */

  1074 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1075 			

  1076 			/* Get the value from a foo(<param_value>) style call */

  1077 			if (IN_param_value == NULL)

  1078 			  IN_param_value = function_call_param_iterator.next();

  1079 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1080 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1081 			

  1082 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

  1083 			{

  1084 		

  1085 				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

  1086 				return return_type_symbol;

  1087 				

  1088 			}

  1089 			

  1090 			ERROR;

  1091 		}

  1092 		

  1093 	}/*function_sint_to_lword*/

  1094 	break;

  1095 

  1096 /****

  1097  *SINT_TO_UINT

  1098  */

  1099 	case function_sint_to_uint :

  1100 	{

  1101 		symbol_c *last_type_symbol = NULL;

  1102 

  1103 		{

  1104 			identifier_c param_name("IN");

  1105 			/* Get the value from a foo(<param_name> = <param_value>) style call */

  1106 			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1107 			

  1108 			/* Get the value from a foo(<param_value>) style call */

  1109 			if (IN_param_value == NULL)

  1110 			  IN_param_value = function_call_param_iterator.next();

  1111 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1112 			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1113 			

  1114 			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

  1115 			{

  1116 		

  1117 				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

  1118 				return return_type_symbol;

  1119 				

  1120 			}

  1121 			

  1122 			ERROR;

  1123 		}

  1124 		

  1125 	}/*function_sint_to_uint*/

  1126 	break;

  1127 

  1128 /****

  1129  *SINT_TO_LREAL

  1130  */

  1131 	case function_sint_to_lreal :

  1132 	{

  1133 		symbol_c *last_type_symbol = NULL;

  1134 

  1135 		{

  1136 			identifier_c param_name("IN");