6 switch(current_function_type){

     6 

     7 

     7 void *compute_standard_function_st(function_invocation_c *symbol) {

     8 /****

     8 

     9  *REAL_TO_REAL

     9   function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);

    10  */

    10   function_call_param_iterator_c function_call_param_iterator(symbol);

    11 	case function_real_to_real :

    11   search_expression_type_c* search_expression_type = this;

    12 	{

    12 

    13 		symbol_c *last_type_symbol = NULL;

    13   switch(current_function_type){

    14 

    14 

    15 		{

    15 /****

    16 			identifier_c param_name("IN");

    16  *REAL_TO_LREAL

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

    17  */

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

    18     case function_real_to_lreal :

    19 			

    19     {

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

    20         symbol_c *last_type_symbol = NULL;

    21 			if (IN_param_value == NULL)

    21 

    22 			  IN_param_value = function_call_param_iterator.next();

    22         {

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

    23             identifier_c param_name("IN");

    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 ;

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

    25 			

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

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

    26             

    27 			{

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

    28 		

    28             if (IN_param_value == NULL)

    29 				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

    29               IN_param_value = function_call_param_iterator.next();

    30 				return return_type_symbol;

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

    31 				

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

    32 			}

    32             

    33 			

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

    34 			ERROR;

    34             {

    35 		}

    35         

    36 		

    36                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

    37 	}/*function_real_to_real*/

    37                 return return_type_symbol;

    38 	break;

    38                 

    39             }

    40             

    41             ERROR;

    42         }

    43         

    44     }/*function_real_to_lreal*/

    45     break;

    43 	case function_real_to_sint :

    50     case function_real_to_sint :

    44 	{

    51     {

    45 		symbol_c *last_type_symbol = NULL;

    52         symbol_c *last_type_symbol = NULL;

    46 

    53 

    47 		{

    54         {

    48 			identifier_c param_name("IN");

    55             identifier_c param_name("IN");

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

    56             /* 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);

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

    51 			

    58             

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

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

    53 			if (IN_param_value == NULL)

    60             if (IN_param_value == NULL)

    54 			  IN_param_value = function_call_param_iterator.next();

    61               IN_param_value = function_call_param_iterator.next();

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

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

    63             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 			

    64             

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

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

    59 			{

    66             {

    60 		

    67         

    61 				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    68                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    62 				return return_type_symbol;

    69                 return return_type_symbol;

    63 				

    70                 

    64 			}

    71             }

    65 			

    72             

    66 			ERROR;

    73             ERROR;

    67 		}

    74         }

    68 		

    75         

    69 	}/*function_real_to_sint*/

    76     }/*function_real_to_sint*/

    70 	break;

    77     break;

    78 

    79 /****

    80  *REAL_TO_INT

    81  */

    82     case function_real_to_int :

    83     {

    84         symbol_c *last_type_symbol = NULL;

    85 

    86         {

    87             identifier_c param_name("IN");

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

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

    90             

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

    92             if (IN_param_value == NULL)

    93               IN_param_value = function_call_param_iterator.next();

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

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

    96             

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

    98             {

    99         

   100                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   101                 return return_type_symbol;

   102                 

   103             }

   104             

   105             ERROR;

   106         }

   107         

   108     }/*function_real_to_int*/

   109     break;

   110 

   111 /****

   112  *REAL_TO_DINT

   113  */

   114     case function_real_to_dint :

   115     {

   116         symbol_c *last_type_symbol = NULL;

   117 

   118         {

   119             identifier_c param_name("IN");

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

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

   122             

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

   124             if (IN_param_value == NULL)

   125               IN_param_value = function_call_param_iterator.next();

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

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

   128             

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

   130             {

   131         

   132                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   133                 return return_type_symbol;

   134                 

   135             }

   136             

   137             ERROR;

   138         }

   139         

   140     }/*function_real_to_dint*/

   141     break;

    75 	case function_real_to_lint :

   146     case function_real_to_lint :

    76 	{

   147     {

    77 		symbol_c *last_type_symbol = NULL;

   148         symbol_c *last_type_symbol = NULL;

    78 

   149 

    79 		{

   150         {

    80 			identifier_c param_name("IN");

   151             identifier_c param_name("IN");

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

   152             /* 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);

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

    83 			

   154             

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

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

    85 			if (IN_param_value == NULL)

   156             if (IN_param_value == NULL)

    86 			  IN_param_value = function_call_param_iterator.next();

   157               IN_param_value = function_call_param_iterator.next();

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

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

   159             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 			

   160             

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

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

    91 			{

   162             {

    92 		

   163         

    93 				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   164                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

    94 				return return_type_symbol;

   165                 return return_type_symbol;

    95 				

   166                 

    96 			}

   167             }

    97 			

   168             

    98 			ERROR;

   169             ERROR;

    99 		}

   170         }

   100 		

   171         

   101 	}/*function_real_to_lint*/

   172     }/*function_real_to_lint*/

   102 	break;

   173     break;

   174 

   175 /****

   176  *REAL_TO_USINT

   177  */

   178     case function_real_to_usint :

   179     {

   180         symbol_c *last_type_symbol = NULL;

   181 

   182         {

   183             identifier_c param_name("IN");

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

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

   186             

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

   188             if (IN_param_value == NULL)

   189               IN_param_value = function_call_param_iterator.next();

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

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

   192             

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

   194             {

   195         

   196                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   197                 return return_type_symbol;

   198                 

   199             }

   200             

   201             ERROR;

   202         }

   203         

   204     }/*function_real_to_usint*/

   205     break;

   206 

   207 /****

   208  *REAL_TO_UINT

   209  */

   210     case function_real_to_uint :

   211     {

   212         symbol_c *last_type_symbol = NULL;

   213 

   214         {

   215             identifier_c param_name("IN");

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

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

   218             

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

   220             if (IN_param_value == NULL)

   221               IN_param_value = function_call_param_iterator.next();

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

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

   224             

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

   226             {

   227         

   228                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   229                 return return_type_symbol;

   230                 

   231             }

   232             

   233             ERROR;

   234         }

   235         

   236     }/*function_real_to_uint*/

   237     break;

   238 

   239 /****

   240  *REAL_TO_UDINT

   241  */

   242     case function_real_to_udint :

   243     {

   244         symbol_c *last_type_symbol = NULL;

   245 

   246         {

   247             identifier_c param_name("IN");

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

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

   250             

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

   252             if (IN_param_value == NULL)

   253               IN_param_value = function_call_param_iterator.next();

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

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

   256             

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

   258             {

   259         

   260                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   261                 return return_type_symbol;

   262                 

   263             }

   264             

   265             ERROR;

   266         }

   267         

   268     }/*function_real_to_udint*/

   269     break;

   270 

   271 /****

   272  *REAL_TO_ULINT

   273  */

   274     case function_real_to_ulint :

   275     {

   276         symbol_c *last_type_symbol = NULL;

   277 

   278         {

   279             identifier_c param_name("IN");

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

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

   282             

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

   284             if (IN_param_value == NULL)

   285               IN_param_value = function_call_param_iterator.next();

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

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

   288             

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

   290             {

   291         

   292                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   293                 return return_type_symbol;

   294                 

   295             }

   296             

   297             ERROR;

   298         }

   299         

   300     }/*function_real_to_ulint*/

   301     break;

   302 

   303 /****

   304  *REAL_TO_TIME

   305  */

   306     case function_real_to_time :

   307     {

   308         symbol_c *last_type_symbol = NULL;

   309 

   310         {

   311             identifier_c param_name("IN");

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

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

   314             

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

   316             if (IN_param_value == NULL)

   317               IN_param_value = function_call_param_iterator.next();

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

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

   320             

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

   322             {

   323         

   324                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   325                 return return_type_symbol;

   326                 

   327             }

   328             

   329             ERROR;

   330         }

   331         

   332     }/*function_real_to_time*/

   333     break;

   334 

   335 /****

   336  *REAL_TO_BOOL

   337  */

   338     case function_real_to_bool :

   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::bool_type_name;

   357                 return return_type_symbol;

   358                 

   359             }

   360             

   361             ERROR;

   362         }

   363         

   364     }/*function_real_to_bool*/

   365     break;

   366 

   367 /****

   368  *REAL_TO_BYTE

   369  */

   370     case function_real_to_byte :

   371     {

   372         symbol_c *last_type_symbol = NULL;

   373 

   374         {

   375             identifier_c param_name("IN");

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

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

   378             

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

   380             if (IN_param_value == NULL)

   381               IN_param_value = function_call_param_iterator.next();

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

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

   384             

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

   386             {

   387         

   388                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   389                 return return_type_symbol;

   390                 

   391             }

   392             

   393             ERROR;

   394         }

   395         

   396     }/*function_real_to_byte*/

   397     break;

   398 

   399 /****

   400  *REAL_TO_WORD

   401  */

   402     case function_real_to_word :

   403     {

   404         symbol_c *last_type_symbol = NULL;

   405 

   406         {

   407             identifier_c param_name("IN");

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

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

   410             

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

   412             if (IN_param_value == NULL)

   413               IN_param_value = function_call_param_iterator.next();

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

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

   416             

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

   418             {

   419         

   420                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   421                 return return_type_symbol;

   422                 

   423             }

   424             

   425             ERROR;

   426         }

   427         

   428     }/*function_real_to_word*/

   429     break;

   430 

   431 /****

   432  *REAL_TO_DWORD

   433  */

   434     case function_real_to_dword :

   435     {

   436         symbol_c *last_type_symbol = NULL;

   437 

   438         {

   439             identifier_c param_name("IN");

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

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

   442             

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

   444             if (IN_param_value == NULL)

   445               IN_param_value = function_call_param_iterator.next();

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

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

   448             

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

   450             {

   451         

   452                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   453                 return return_type_symbol;

   454                 

   455             }

   456             

   457             ERROR;

   458         }

   459         

   460     }/*function_real_to_dword*/

   461     break;

   462 

   463 /****

   464  *REAL_TO_LWORD

   465  */

   466     case function_real_to_lword :

   467     {

   468         symbol_c *last_type_symbol = NULL;

   469 

   470         {

   471             identifier_c param_name("IN");

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

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

   474             

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

   476             if (IN_param_value == NULL)

   477               IN_param_value = function_call_param_iterator.next();

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

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

   480             

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

   482             {

   483         

   484                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   485                 return return_type_symbol;

   486                 

   487             }

   488             

   489             ERROR;

   490         }

   491         

   492     }/*function_real_to_lword*/

   493     break;

   494 

   495 /****

   496  *REAL_TO_STRING

   497  */

   498     case function_real_to_string :

   499     {

   500         symbol_c *last_type_symbol = NULL;

   501 

   502         {

   503             identifier_c param_name("IN");

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

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

   506             

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

   508             if (IN_param_value == NULL)

   509               IN_param_value = function_call_param_iterator.next();

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

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

   512             

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

   514             {

   515         

   516                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   517                 return return_type_symbol;

   518                 

   519             }

   520             

   521             ERROR;

   522         }

   523         

   524     }/*function_real_to_string*/

   525     break;

   526 

   527 /****

   528  *REAL_TO_WSTRING

   529  */

   530     case function_real_to_wstring :

   531     {

   532         symbol_c *last_type_symbol = NULL;

   533 

   534         {

   535             identifier_c param_name("IN");

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

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

   538             

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

   540             if (IN_param_value == NULL)

   541               IN_param_value = function_call_param_iterator.next();

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

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

   544             

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

   546             {

   547         

   548                 symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;

   549                 return return_type_symbol;

   550                 

   551             }

   552             

   553             ERROR;

   554         }

   555         

   556     }/*function_real_to_wstring*/

   557     break;

   558 

   559 /****

   560  *REAL_TO_DATE

   561  */

   562     case function_real_to_date :

   563     {

   564         symbol_c *last_type_symbol = NULL;

   565 

   566         {

   567             identifier_c param_name("IN");

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

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

   570             

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

   572             if (IN_param_value == NULL)

   573               IN_param_value = function_call_param_iterator.next();

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

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

   576             

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

   578             {

   579         

   580                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   581                 return return_type_symbol;

   582                 

   583             }

   584             

   585             ERROR;

   586         }

   587         

   588     }/*function_real_to_date*/

   589     break;

   590 

   591 /****

   592  *REAL_TO_TOD

   593  */

   594     case function_real_to_tod :

   595     {

   596         symbol_c *last_type_symbol = NULL;

   597 

   598         {

   599             identifier_c param_name("IN");

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

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

   602             

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

   604             if (IN_param_value == NULL)

   605               IN_param_value = function_call_param_iterator.next();

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

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

   608             

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

   610             {

   611         

   612                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   613                 return return_type_symbol;

   614                 

   615             }

   616             

   617             ERROR;

   618         }

   619         

   620     }/*function_real_to_tod*/

   621     break;

   622 

   623 /****

   624  *REAL_TO_DT

   625  */

   626     case function_real_to_dt :

   627     {

   628         symbol_c *last_type_symbol = NULL;

   629 

   630         {

   631             identifier_c param_name("IN");

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

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

   634             

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

   636             if (IN_param_value == NULL)

   637               IN_param_value = function_call_param_iterator.next();

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

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

   640             

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

   642             {

   643         

   644                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   645                 return return_type_symbol;

   646                 

   647             }

   648             

   649             ERROR;

   650         }

   651         

   652     }/*function_real_to_dt*/

   653     break;

   654 

   655 /****

   656  *LREAL_TO_REAL

   657  */

   658     case function_lreal_to_real :

   659     {

   660         symbol_c *last_type_symbol = NULL;

   661 

   662         {

   663             identifier_c param_name("IN");

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

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

   666             

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

   668             if (IN_param_value == NULL)

   669               IN_param_value = function_call_param_iterator.next();

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

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

   672             

   673             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   674             {

   675         

   676                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   677                 return return_type_symbol;

   678                 

   679             }

   680             

   681             ERROR;

   682         }

   683         

   684     }/*function_lreal_to_real*/

   685     break;

   686 

   687 /****

   688  *LREAL_TO_SINT

   689  */

   690     case function_lreal_to_sint :

   691     {

   692         symbol_c *last_type_symbol = NULL;

   693 

   694         {

   695             identifier_c param_name("IN");

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

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

   698             

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

   700             if (IN_param_value == NULL)

   701               IN_param_value = function_call_param_iterator.next();

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

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

   704             

   705             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   706             {

   707         

   708                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

   709                 return return_type_symbol;

   710                 

   711             }

   712             

   713             ERROR;

   714         }

   715         

   716     }/*function_lreal_to_sint*/

   717     break;

   718 

   719 /****

   720  *LREAL_TO_INT

   721  */

   722     case function_lreal_to_int :

   723     {

   724         symbol_c *last_type_symbol = NULL;

   725 

   726         {

   727             identifier_c param_name("IN");

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

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

   730             

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

   732             if (IN_param_value == NULL)

   733               IN_param_value = function_call_param_iterator.next();

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

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

   736             

   737             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   738             {

   739         

   740                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   741                 return return_type_symbol;

   742                 

   743             }

   744             

   745             ERROR;

   746         }

   747         

   748     }/*function_lreal_to_int*/

   749     break;

   750 

   751 /****

   752  *LREAL_TO_DINT

   753  */

   754     case function_lreal_to_dint :

   755     {

   756         symbol_c *last_type_symbol = NULL;

   757 

   758         {

   759             identifier_c param_name("IN");

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

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

   762             

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

   764             if (IN_param_value == NULL)

   765               IN_param_value = function_call_param_iterator.next();

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

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

   768             

   769             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   770             {

   771         

   772                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   773                 return return_type_symbol;

   774                 

   775             }

   776             

   777             ERROR;

   778         }

   779         

   780     }/*function_lreal_to_dint*/

   781     break;

   782 

   783 /****

   784  *LREAL_TO_LINT

   785  */

   786     case function_lreal_to_lint :

   787     {

   788         symbol_c *last_type_symbol = NULL;

   789 

   790         {

   791             identifier_c param_name("IN");

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

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

   794             

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

   796             if (IN_param_value == NULL)

   797               IN_param_value = function_call_param_iterator.next();

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

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

   800             

   801             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   802             {

   803         

   804                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   805                 return return_type_symbol;

   806                 

   807             }

   808             

   809             ERROR;

   810         }

   811         

   812     }/*function_lreal_to_lint*/

   813     break;

   814 

   815 /****

   816  *LREAL_TO_USINT

   817  */

   818     case function_lreal_to_usint :

   819     {

   820         symbol_c *last_type_symbol = NULL;

   821 

   822         {

   823             identifier_c param_name("IN");

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

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

   826             

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

   828             if (IN_param_value == NULL)

   829               IN_param_value = function_call_param_iterator.next();

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

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

   832             

   833             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   834             {

   835         

   836                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   837                 return return_type_symbol;

   838                 

   839             }

   840             

   841             ERROR;

   842         }

   843         

   844     }/*function_lreal_to_usint*/

   845     break;

   846 

   847 /****

   848  *LREAL_TO_UINT

   849  */

   850     case function_lreal_to_uint :

   851     {

   852         symbol_c *last_type_symbol = NULL;

   853 

   854         {

   855             identifier_c param_name("IN");

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

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

   858             

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

   860             if (IN_param_value == NULL)

   861               IN_param_value = function_call_param_iterator.next();

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

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

   864             

   865             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   866             {

   867         

   868                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   869                 return return_type_symbol;

   870                 

   871             }

   872             

   873             ERROR;

   874         }

   875         

   876     }/*function_lreal_to_uint*/

   877     break;

   878 

   879 /****

   880  *LREAL_TO_UDINT

   881  */

   882     case function_lreal_to_udint :

   883     {

   884         symbol_c *last_type_symbol = NULL;

   885 

   886         {

   887             identifier_c param_name("IN");

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

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

   890             

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

   892             if (IN_param_value == NULL)

   893               IN_param_value = function_call_param_iterator.next();

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

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

   896             

   897             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   898             {

   899         

   900                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   901                 return return_type_symbol;

   902                 

   903             }

   904             

   905             ERROR;

   906         }

   907         

   908     }/*function_lreal_to_udint*/

   909     break;

   910 

   911 /****

   912  *LREAL_TO_ULINT

   913  */

   914     case function_lreal_to_ulint :

   915     {

   916         symbol_c *last_type_symbol = NULL;

   917 

   918         {

   919             identifier_c param_name("IN");

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

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

   922             

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

   924             if (IN_param_value == NULL)

   925               IN_param_value = function_call_param_iterator.next();

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

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

   928             

   929             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   930             {

   931         

   932                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   933                 return return_type_symbol;

   934                 

   935             }

   936             

   937             ERROR;

   938         }

   939         

   940     }/*function_lreal_to_ulint*/

   941     break;

   942 

   943 /****

   944  *LREAL_TO_TIME

   945  */

   946     case function_lreal_to_time :

   947     {

   948         symbol_c *last_type_symbol = NULL;

   949 

   950         {

   951             identifier_c param_name("IN");

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

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

   954             

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

   956             if (IN_param_value == NULL)

   957               IN_param_value = function_call_param_iterator.next();

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

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

   960             

   961             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   962             {

   963         

   964                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   965                 return return_type_symbol;

   966                 

   967             }

   968             

   969             ERROR;

   970         }

   971         

   972     }/*function_lreal_to_time*/

   973     break;

   974 

   975 /****

   976  *LREAL_TO_BOOL

   977  */

   978     case function_lreal_to_bool :

   979     {

   980         symbol_c *last_type_symbol = NULL;

   981 

   982         {

   983             identifier_c param_name("IN");

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

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

   986             

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

   988             if (IN_param_value == NULL)

   989               IN_param_value = function_call_param_iterator.next();

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

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

   992             

   993             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   994             {

   995         

   996                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   997                 return return_type_symbol;

   998                 

   999             }

  1000             

  1001             ERROR;

  1002         }

  1003         

  1004     }/*function_lreal_to_bool*/

  1005     break;

  1006 

  1007 /****

  1008  *LREAL_TO_BYTE

  1009  */

  1010     case function_lreal_to_byte :

  1011     {

  1012         symbol_c *last_type_symbol = NULL;

  1013 

  1014         {

  1015             identifier_c param_name("IN");

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

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

  1018             

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

  1020             if (IN_param_value == NULL)

  1021               IN_param_value = function_call_param_iterator.next();

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

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

  1024             

  1025             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1026             {

  1027         

  1028                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

  1029                 return return_type_symbol;

  1030                 

  1031             }

  1032             

  1033             ERROR;

  1034         }

  1035         

  1036     }/*function_lreal_to_byte*/

  1037     break;

  1038 

  1039 /****

  1040  *LREAL_TO_WORD

  1041  */

  1042     case function_lreal_to_word :

  1043     {

  1044         symbol_c *last_type_symbol = NULL;

  1045 

  1046         {

  1047             identifier_c param_name("IN");

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

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

  1050             

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

  1052             if (IN_param_value == NULL)

  1053               IN_param_value = function_call_param_iterator.next();

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

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

  1056             

  1057             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1058             {

  1059         

  1060                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

  1061                 return return_type_symbol;

  1062                 

  1063             }

  1064             

  1065             ERROR;

  1066         }

  1067         

  1068     }/*function_lreal_to_word*/

  1069     break;

  1070 

  1071 /****

  1072  *LREAL_TO_DWORD

  1073  */

  1074     case function_lreal_to_dword :

  1075     {

  1076         symbol_c *last_type_symbol = NULL;

  1077 

  1078         {

  1079             identifier_c param_name("IN");

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

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

  1082             

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

  1084             if (IN_param_value == NULL)

  1085               IN_param_value = function_call_param_iterator.next();

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

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

  1088             

  1089             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1090             {

  1091         

  1092                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

  1093                 return return_type_symbol;

  1094                 

  1095             }

  1096             

  1097             ERROR;

  1098         }

  1099         

  1100     }/*function_lreal_to_dword*/

  1101     break;

  1102 

  1103 /****

  1104  *LREAL_TO_LWORD

  1105  */

  1106     case function_lreal_to_lword :

  1107     {

  1108         symbol_c *last_type_symbol = NULL;

  1109 

  1110         {

  1111             identifier_c param_name("IN");

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

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

  1114             

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

  1116             if (IN_param_value == NULL)

  1117               IN_param_value = function_call_param_iterator.next();

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

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

  1120             

  1121             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1122             {

  1123         

  1124                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

  1125                 return return_type_symbol;

  1126                 

  1127             }

  1128             

  1129             ERROR;

  1130         }

  1131         

  1132     }/*function_lreal_to_lword*/

  1133     break;

  1134 

  1135 /****