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 				s4o.print("(");

    31 				return_type_symbol->accept(*this);

    32 				s4o.print(")");

    33 				IN_param_value->accept(*this);

    34 				return NULL;

    35 				

    36 			}

    37 			

    38 			ERROR;

    39 		}

    40 		

    41 	}/*function_real_to_real*/

    42 	break;

    43 

    44 /****

    45  *REAL_TO_SINT

    46  */

    47 	case function_real_to_sint :

    48 	{

    49 		symbol_c *last_type_symbol = NULL;

    50 

    51 		{

    52 			identifier_c param_name("IN");

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

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

    55 			

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

    57 			if (IN_param_value == NULL)

    58 			  IN_param_value = function_call_param_iterator.next();

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

    60 			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 ;

    61 			

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

    63 			{

    64 		

    65 				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    66 				s4o.print("(");

    67 				return_type_symbol->accept(*this);

    68 				s4o.print(")");

    69 				IN_param_value->accept(*this);

    70 				return NULL;

    71 				

    72 			}

    73 			

    74 			ERROR;

    75 		}

    76 		

    77 	}/*function_real_to_sint*/

    78 	break;

    79 

    80 /****

    81  *REAL_TO_LINT

    82  */

    83 	case function_real_to_lint :

    84 	{

    85 		symbol_c *last_type_symbol = NULL;

    86 

    87 		{

    88 			identifier_c param_name("IN");

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

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

    91 			

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

    93 			if (IN_param_value == NULL)

    94 			  IN_param_value = function_call_param_iterator.next();

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

    96 			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 ;

    97 			

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

    99 			{

   100 		

   101 				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   102 				s4o.print("(");

   103 				return_type_symbol->accept(*this);

   104 				s4o.print(")");

   105 				IN_param_value->accept(*this);

   106 				return NULL;

   107 				

   108 			}

   109 			

   110 			ERROR;

   111 		}

   112 		

   113 	}/*function_real_to_lint*/

   114 	break;

   115 

   116 /****

   117  *REAL_TO_DINT

   118  */

   119 	case function_real_to_dint :

   120 	{

   121 		symbol_c *last_type_symbol = NULL;

   122 

   123 		{

   124 			identifier_c param_name("IN");

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

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

   127 			

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

   129 			if (IN_param_value == NULL)

   130 			  IN_param_value = function_call_param_iterator.next();

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

   132 			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 ;

   133 			

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

   135 			{

   136 		

   137 				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   138 				s4o.print("(");

   139 				return_type_symbol->accept(*this);

   140 				s4o.print(")");

   141 				IN_param_value->accept(*this);

   142 				return NULL;

   143 				

   144 			}

   145 			

   146 			ERROR;

   147 		}

   148 		

   149 	}/*function_real_to_dint*/

   150 	break;

   151 

   152 /****

   153  *REAL_TO_DATE

   154  */

   155 	case function_real_to_date :

   156 	{

   157 		symbol_c *last_type_symbol = NULL;

   158 

   159 		{

   160 			identifier_c param_name("IN");

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

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

   163 			

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

   165 			if (IN_param_value == NULL)

   166 			  IN_param_value = function_call_param_iterator.next();

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

   168 			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 ;

   169 			

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

   171 			{

   172 		

   173 				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   174 				s4o.print("(");

   175 				return_type_symbol->accept(*this);

   176 				s4o.print(")time_to_real(");

   177 				IN_param_value->accept(*this);

   178 				s4o.print(")");

   179 				return NULL;

   180 				

   181 			}

   182 			

   183 			ERROR;

   184 		}

   185 		

   186 	}/*function_real_to_date*/

   187 	break;

   188 

   189 /****

   190  *REAL_TO_DWORD

   191  */

   192 	case function_real_to_dword :

   193 	{

   194 		symbol_c *last_type_symbol = NULL;

   195 

   196 		{

   197 			identifier_c param_name("IN");

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

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

   200 			

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

   202 			if (IN_param_value == NULL)

   203 			  IN_param_value = function_call_param_iterator.next();

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

   205 			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 ;

   206 			

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

   208 			{

   209 		

   210 				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   211 				s4o.print("(");

   212 				return_type_symbol->accept(*this);

   213 				s4o.print(")");

   214 				IN_param_value->accept(*this);

   215 				return NULL;

   216 				

   217 			}

   218 			

   219 			ERROR;

   220 		}

   221 		

   222 	}/*function_real_to_dword*/

   223 	break;

   224 

   225 /****

   226  *REAL_TO_DT

   227  */

   228 	case function_real_to_dt :

   229 	{

   230 		symbol_c *last_type_symbol = NULL;

   231 

   232 		{

   233 			identifier_c param_name("IN");

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

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

   236 			

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

   238 			if (IN_param_value == NULL)

   239 			  IN_param_value = function_call_param_iterator.next();

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

   241 			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 ;

   242 			

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

   244 			{

   245 		

   246 				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   247 				s4o.print("(");

   248 				return_type_symbol->accept(*this);

   249 				s4o.print(")time_to_real(");

   250 				IN_param_value->accept(*this);

   251 				s4o.print(")");

   252 				return NULL;

   253 				

   254 			}

   255 			

   256 			ERROR;

   257 		}

   258 		

   259 	}/*function_real_to_dt*/

   260 	break;

   261 

   262 /****

   263  *REAL_TO_TOD

   264  */

   265 	case function_real_to_tod :

   266 	{

   267 		symbol_c *last_type_symbol = NULL;

   268 

   269 		{

   270 			identifier_c param_name("IN");

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

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

   273 			

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

   275 			if (IN_param_value == NULL)

   276 			  IN_param_value = function_call_param_iterator.next();

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

   278 			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 ;

   279 			

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

   281 			{

   282 		

   283 				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   284 				s4o.print("(");

   285 				return_type_symbol->accept(*this);

   286 				s4o.print(")time_to_real(");

   287 				IN_param_value->accept(*this);

   288 				s4o.print(")");

   289 				return NULL;

   290 				

   291 			}

   292 			

   293 			ERROR;

   294 		}

   295 		

   296 	}/*function_real_to_tod*/

   297 	break;

   298 

   299 /****

   300  *REAL_TO_UDINT

   301  */

   302 	case function_real_to_udint :

   303 	{

   304 		symbol_c *last_type_symbol = NULL;

   305 

   306 		{

   307 			identifier_c param_name("IN");

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

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

   310 			

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

   312 			if (IN_param_value == NULL)

   313 			  IN_param_value = function_call_param_iterator.next();

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

   315 			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 ;

   316 			

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

   318 			{

   319 		

   320 				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   321 				s4o.print("(");

   322 				return_type_symbol->accept(*this);

   323 				s4o.print(")");

   324 				IN_param_value->accept(*this);

   325 				return NULL;

   326 				

   327 			}

   328 			

   329 			ERROR;

   330 		}

   331 		

   332 	}/*function_real_to_udint*/

   333 	break;

   334 

   335 /****

   336  *REAL_TO_WORD

   337  */

   338 	case function_real_to_word :

   339 	{

   340 		symbol_c *last_type_symbol = NULL;

   341 

   342 		{

   343 			identifier_c param_name("IN");

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

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

   346 			

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

   348 			if (IN_param_value == NULL)

   349 			  IN_param_value = function_call_param_iterator.next();

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

   351 			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 ;

   352 			

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

   354 			{

   355 		

   356 				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   357 				s4o.print("(");

   358 				return_type_symbol->accept(*this);

   359 				s4o.print(")");

   360 				IN_param_value->accept(*this);

   361 				return NULL;

   362 				

   363 			}

   364 			

   365 			ERROR;

   366 		}

   367 		

   368 	}/*function_real_to_word*/

   369 	break;

   370 

   371 /****

   372  *REAL_TO_WSTRING

   373  */

   374 	case function_real_to_wstring :

   375 	{

   376 		symbol_c *last_type_symbol = NULL;

   377 

   378 		{

   379 			identifier_c param_name("IN");

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

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

   382 			

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

   384 			if (IN_param_value == NULL)

   385 			  IN_param_value = function_call_param_iterator.next();

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

   387 			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 ;

   388 			

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

   390 			{

   391 		

   392 				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;

   393 				s4o.print("(");

   394 				return_type_symbol->accept(*this);

   395 				s4o.print(")string_to_int(");

   396 				IN_param_value->accept(*this);

   397 				s4o.print(", 10)");

   398 				return NULL;

   399 				

   400 			}

   401 			

   402 			ERROR;

   403 		}

   404 		

   405 	}/*function_real_to_wstring*/

   406 	break;

   407 

   408 /****

   409  *REAL_TO_STRING

   410  */

   411 	case function_real_to_string :

   412 	{

   413 		symbol_c *last_type_symbol = NULL;

   414 

   415 		{

   416 			identifier_c param_name("IN");

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

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

   419 			

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

   421 			if (IN_param_value == NULL)

   422 			  IN_param_value = function_call_param_iterator.next();

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

   424 			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 ;

   425 			

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

   427 			{

   428 		

   429 				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   430 				s4o.print("(");

   431 				return_type_symbol->accept(*this);

   432 				s4o.print(")string_to_int(");

   433 				IN_param_value->accept(*this);

   434 				s4o.print(", 10)");

   435 				return NULL;

   436 				

   437 			}

   438 			

   439 			ERROR;

   440 		}

   441 		

   442 	}/*function_real_to_string*/

   443 	break;

   444 

   445 /****

   446  *REAL_TO_LWORD

   447  */

   448 	case function_real_to_lword :

   449 	{

   450 		symbol_c *last_type_symbol = NULL;

   451 

   452 		{

   453 			identifier_c param_name("IN");

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

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

   456 			

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

   458 			if (IN_param_value == NULL)

   459 			  IN_param_value = function_call_param_iterator.next();

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

   461 			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 ;

   462 			

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

   464 			{

   465 		

   466 				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   467 				s4o.print("(");

   468 				return_type_symbol->accept(*this);

   469 				s4o.print(")");

   470 				IN_param_value->accept(*this);

   471 				return NULL;

   472 				

   473 			}

   474 			

   475 			ERROR;

   476 		}

   477 		

   478 	}/*function_real_to_lword*/

   479 	break;

   480 

   481 /****

   482  *REAL_TO_UINT

   483  */

   484 	case function_real_to_uint :

   485 	{

   486 		symbol_c *last_type_symbol = NULL;

   487 

   488 		{

   489 			identifier_c param_name("IN");

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

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

   492 			

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

   494 			if (IN_param_value == NULL)

   495 			  IN_param_value = function_call_param_iterator.next();

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

   497 			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 ;

   498 			

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

   500 			{

   501 		

   502 				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   503 				s4o.print("(");

   504 				return_type_symbol->accept(*this);

   505 				s4o.print(")");

   506 				IN_param_value->accept(*this);

   507 				return NULL;

   508 				

   509 			}

   510 			

   511 			ERROR;

   512 		}

   513 		

   514 	}/*function_real_to_uint*/

   515 	break;

   516 

   517 /****

   518  *REAL_TO_LREAL

   519  */

   520 	case function_real_to_lreal :

   521 	{

   522 		symbol_c *last_type_symbol = NULL;

   523 

   524 		{

   525 			identifier_c param_name("IN");

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

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

   528 			

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

   530 			if (IN_param_value == NULL)

   531 			  IN_param_value = function_call_param_iterator.next();

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

   533 			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 ;

   534 			

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

   536 			{

   537 		

   538 				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   539 				s4o.print("(");

   540 				return_type_symbol->accept(*this);

   541 				s4o.print(")");

   542 				IN_param_value->accept(*this);

   543 				return NULL;

   544 				

   545 			}

   546 			

   547 			ERROR;

   548 		}

   549 		

   550 	}/*function_real_to_lreal*/

   551 	break;

   552 

   553 /****

   554  *REAL_TO_BYTE

   555  */

   556 	case function_real_to_byte :

   557 	{

   558 		symbol_c *last_type_symbol = NULL;

   559 

   560 		{

   561 			identifier_c param_name("IN");

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

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

   564 			

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

   566 			if (IN_param_value == NULL)

   567 			  IN_param_value = function_call_param_iterator.next();

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

   569 			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 ;

   570 			

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

   572 			{

   573 		

   574 				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   575 				s4o.print("(");

   576 				return_type_symbol->accept(*this);

   577 				s4o.print(")");

   578 				IN_param_value->accept(*this);

   579 				return NULL;

   580 				

   581 			}

   582 			

   583 			ERROR;

   584 		}

   585 		

   586 	}/*function_real_to_byte*/

   587 	break;

   588 

   589 /****

   590  *REAL_TO_USINT

   591  */

   592 	case function_real_to_usint :

   593 	{

   594 		symbol_c *last_type_symbol = NULL;

   595 

   596 		{

   597 			identifier_c param_name("IN");

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

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

   600 			

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

   602 			if (IN_param_value == NULL)

   603 			  IN_param_value = function_call_param_iterator.next();

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

   605 			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 ;

   606 			

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

   608 			{

   609 		

   610 				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   611 				s4o.print("(");

   612 				return_type_symbol->accept(*this);

   613 				s4o.print(")");

   614 				IN_param_value->accept(*this);

   615 				return NULL;

   616 				

   617 			}

   618 			

   619 			ERROR;

   620 		}

   621 		

   622 	}/*function_real_to_usint*/

   623 	break;

   624 

   625 /****

   626  *REAL_TO_ULINT

   627  */

   628 	case function_real_to_ulint :

   629 	{

   630 		symbol_c *last_type_symbol = NULL;

   631 

   632 		{

   633 			identifier_c param_name("IN");

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

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

   636 			

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

   638 			if (IN_param_value == NULL)

   639 			  IN_param_value = function_call_param_iterator.next();

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

   641 			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 ;

   642 			

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

   644 			{

   645 		

   646 				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   647 				s4o.print("(");

   648 				return_type_symbol->accept(*this);

   649 				s4o.print(")");

   650 				IN_param_value->accept(*this);

   651 				return NULL;

   652 				

   653 			}

   654 			

   655 			ERROR;

   656 		}

   657 		

   658 	}/*function_real_to_ulint*/

   659 	break;

   660 

   661 /****

   662  *REAL_TO_BOOL

   663  */

   664 	case function_real_to_bool :

   665 	{

   666 		symbol_c *last_type_symbol = NULL;

   667 

   668 		{

   669 			identifier_c param_name("IN");

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

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

   672 			

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

   674 			if (IN_param_value == NULL)

   675 			  IN_param_value = function_call_param_iterator.next();

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

   677 			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 ;

   678 			

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

   680 			{

   681 		

   682 				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   683 				s4o.print("(");

   684 				return_type_symbol->accept(*this);

   685 				s4o.print(")");

   686 				IN_param_value->accept(*this);

   687 				return NULL;

   688 				

   689 			}

   690 			

   691 			ERROR;

   692 		}

   693 		

   694 	}/*function_real_to_bool*/

   695 	break;

   696 

   697 /****

   698  *REAL_TO_TIME

   699  */

   700 	case function_real_to_time :

   701 	{

   702 		symbol_c *last_type_symbol = NULL;

   703 

   704 		{

   705 			identifier_c param_name("IN");

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

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

   708 			

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

   710 			if (IN_param_value == NULL)

   711 			  IN_param_value = function_call_param_iterator.next();

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

   713 			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 ;

   714 			

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

   716 			{

   717 		

   718 				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   719 				s4o.print("(");

   720 				return_type_symbol->accept(*this);

   721 				s4o.print(")time_to_real(");

   722 				IN_param_value->accept(*this);

   723 				s4o.print(")");

   724 				return NULL;

   725 				

   726 			}

   727 			

   728 			ERROR;

   729 		}

   730 		

   731 	}/*function_real_to_time*/

   732 	break;

   733 

   734 /****

   735  *REAL_TO_INT

   736  */

   737 	case function_real_to_int :

   738 	{

   739 		symbol_c *last_type_symbol = NULL;

   740 

   741 		{

   742 			identifier_c param_name("IN");

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

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

   745 			

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

   747 			if (IN_param_value == NULL)

   748 			  IN_param_value = function_call_param_iterator.next();

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

   750 			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 ;

   751 			

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

   753 			{

   754 		

   755 				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   756 				s4o.print("(");

   757 				return_type_symbol->accept(*this);

   758 				s4o.print(")");

   759 				IN_param_value->accept(*this);

   760 				return NULL;

   761 				

   762 			}

   763 			

   764 			ERROR;

   765 		}

   766 		

   767 	}/*function_real_to_int*/

   768 	break;

   769 

   770 /****

   771  *SINT_TO_REAL

   772  */

   773 	case function_sint_to_real :

   774 	{

   775 		symbol_c *last_type_symbol = NULL;

   776 

   777 		{

   778 			identifier_c param_name("IN");

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

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

   781 			

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

   783 			if (IN_param_value == NULL)

   784 			  IN_param_value = function_call_param_iterator.next();

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

   786 			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 ;

   787 			

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

   789 			{

   790 		

   791 				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   792 				s4o.print("(");

   793 				return_type_symbol->accept(*this);

   794 				s4o.print(")");

   795 				IN_param_value->accept(*this);

   796 				return NULL;

   797 				

   798 			}

   799 			

   800 			ERROR;

   801 		}

   802 		

   803 	}/*function_sint_to_real*/

   804 	break;

   805 

   806 /****

   807  *SINT_TO_SINT

   808  */

   809 	case function_sint_to_sint :

   810 	{

   811 		symbol_c *last_type_symbol = NULL;

   812 

   813 		{

   814 			identifier_c param_name("IN");

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

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

   817 			

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

   819 			if (IN_param_value == NULL)

   820 			  IN_param_value = function_call_param_iterator.next();

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

   822 			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 ;

   823 			

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

   825 			{

   826 		

   827 				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

   828 				s4o.print("(");

   829 				return_type_symbol->accept(*this);

   830 				s4o.print(")");

   831 				IN_param_value->accept(*this);

   832 				return NULL;

   833 				

   834 			}

   835 			

   836 			ERROR;

   837 		}

   838 		

   839 	}/*function_sint_to_sint*/

   840 	break;

   841 

   842 /****

   843  *SINT_TO_LINT

   844  */

   845 	case function_sint_to_lint :

   846 	{

   847 		symbol_c *last_type_symbol = NULL;

   848 

   849 		{

   850 			identifier_c param_name("IN");

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

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

   853 			

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

   855 			if (IN_param_value == NULL)

   856 			  IN_param_value = function_call_param_iterator.next();

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

   858 			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 ;

   859 			

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

   861 			{

   862 		

   863 				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   864 				s4o.print("(");

   865 				return_type_symbol->accept(*this);

   866 				s4o.print(")");

   867 				IN_param_value->accept(*this);

   868 				return NULL;

   869 				

   870 			}

   871 			

   872 			ERROR;

   873 		}

   874 		

   875 	}/*function_sint_to_lint*/

   876 	break;

   877 

   878 /****

   879  *SINT_TO_DINT

   880  */

   881 	case function_sint_to_dint :

   882 	{

   883 		symbol_c *last_type_symbol = NULL;

   884 

   885 		{

   886 			identifier_c param_name("IN");

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

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

   889 			

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

   891 			if (IN_param_value == NULL)

   892 			  IN_param_value = function_call_param_iterator.next();

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

   894 			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 ;

   895 			

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

   897 			{

   898 		

   899 				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   900 				s4o.print("(");

   901 				return_type_symbol->accept(*this);

   902 				s4o.print(")");

   903 				IN_param_value->accept(*this);

   904 				return NULL;

   905 				

   906 			}

   907 			

   908 			ERROR;

   909 		}

   910 		

   911 	}/*function_sint_to_dint*/

   912 	break;

   913 

   914 /****

   915  *SINT_TO_DATE

   916  */

   917 	case function_sint_to_date :

   918 	{

   919 		symbol_c *last_type_symbol = NULL;

   920 

   921 		{

   922 			identifier_c param_name("IN");

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

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

   925 			

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

   927 			if (IN_param_value == NULL)

   928 			  IN_param_value = function_call_param_iterator.next();

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

   930 			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 ;

   931 			

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

   933 			{

   934 		

   935 				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   936 				s4o.print("(");

   937 				return_type_symbol->accept(*this);

   938 				s4o.print(")time_to_real(");

   939 				IN_param_value->accept(*this);

   940 				s4o.print(")");

   941 				return NULL;

   942 				

   943 			}

   944 			

   945 			ERROR;

   946 		}

   947 		

   948 	}/*function_sint_to_date*/

   949 	break;

   950 

   951 /****

   952  *SINT_TO_DWORD

   953  */

   954 	case function_sint_to_dword :

   955 	{

   956 		symbol_c *last_type_symbol = NULL;

   957 

   958 		{

   959 			identifier_c param_name("IN");

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

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

   962 			

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

   964 			if (IN_param_value == NULL)

   965 			  IN_param_value = function_call_param_iterator.next();

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

   967 			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 ;

   968 			

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

   970 			{

   971 		

   972 				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   973 				s4o.print("(");

   974 				return_type_symbol->accept(*this);

   975 				s4o.print(")");

   976 				IN_param_value->accept(*this);

   977 				return NULL;

   978 				

   979 			}

   980 			

   981 			ERROR;

   982 		}

   983 		

   984 	}/*function_sint_to_dword*/

   985 	break;

   986 

   987 /****

   988  *SINT_TO_DT

   989  */

   990 	case function_sint_to_dt :

   991 	{

   992 		symbol_c *last_type_symbol = NULL;

   993 

   994 		{

   995 			identifier_c param_name("IN");

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

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

   998 			

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

  1000 			if (IN_param_value == NULL)

  1001 			  IN_param_value = function_call_param_iterator.next();

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

  1003 			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 ;

  1004 			

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

  1006 			{

  1007 		

  1008 				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

  1009 				s4o.print("(");

  1010 				return_type_symbol->accept(*this);

  1011 				s4o.print(")time_to_real(");

  1012 				IN_param_value->accept(*this);

  1013 				s4o.print(")");

  1014 				return NULL;

  1015 				

  1016 			}

  1017 			

  1018 			ERROR;

  1019 		}

  1020 		

  1021 	}/*function_sint_to_dt*/

  1022 	break;

  1023 

  1024 /****

  1025  *SINT_TO_TOD

  1026  */

  1027 	case function_sint_to_tod :

  1028 	{

  1029 		symbol_c *last_type_symbol = NULL;

  1030 

  1031 		{

  1032 			identifier_c param_name("IN");

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

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

  1035 			

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

  1037 			if (IN_param_value == NULL)

  1038 			  IN_param_value = function_call_param_iterator.next();

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

  1040 			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 ;

  1041 			

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

  1043 			{

  1044 		

  1045 				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

  1046 				s4o.print("(");

  1047 				return_type_symbol->accept(*this);

  1048 				s4o.print(")time_to_real(");

  1049 				IN_param_value->accept(*this);

  1050 				s4o.print(")");

  1051 				return NULL;

  1052 				

  1053 			}

  1054 			

  1055 			ERROR;

  1056 		}

  1057 		

  1058 	}/*function_sint_to_tod*/

  1059 	break;

  1060 

  1061 /****

  1062  *SINT_TO_UDINT

  1063  */

  1064 	case function_sint_to_udint :

  1065 	{

  1066 		symbol_c *last_type_symbol = NULL;

  1067 

  1068 		{

  1069 			identifier_c param_name("IN");

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

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

  1072 			

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

  1074 			if (IN_param_value == NULL)

  1075 			  IN_param_value = function_call_param_iterator.next();

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

  1077 			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 ;

  1078 			

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

  1080 			{

  1081 		

  1082 				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

  1083 				s4o.print("(");

  1084 				return_type_symbol->accept(*this);

  1085 				s4o.print(")");

  1086 				IN_param_value->accept(*this);

  1087 				return NULL;

  1088 				

  1089 			}

  1090 			

  1091 			ERROR;

  1092 		}

  1093 		

  1094 	}/*function_sint_to_udint*/

  1095 	break;

  1096 

  1097 /****

  1098  *SINT_TO_WORD

  1099  */

  1100 	case function_sint_to_word :

  1101 	{

  1102 		symbol_c *last_type_symbol = NULL;

  1103 

  1104 		{

  1105 			identifier_c param_name("IN");

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

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

  1108 			

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

  1110 			if (IN_param_value == NULL)

  1111 			  IN_param_value = function_call_param_iterator.next();

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

  1113 			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 ;

  1114 			

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

  1116 			{

  1117 		

  1118 				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

  1119 				s4o.print("(");

  1120 				return_type_symbol->accept(*this);

  1121 				s4o.print(")");

  1122 				IN_param_value->accept(*this);

  1123 				return NULL;

  1124 				

  1125 			}

  1126 			

  1127 			ERROR;

  1128 		}

  1129 		

  1130 	}/*function_sint_to_word*/

  1131 	break;

  1132 

  1133 /****

  1134  *SINT_TO_WSTRING

  1135  */

  1136 	case function_sint_to_wstring :