9  *REAL_TO_REAL

     9  *REAL_TO_LREAL

    10  */

    10  */

    11 	case function_real_to_real :

    11     case function_real_to_lreal :

    12 	{

    12     {

    13 		symbol_c *last_type_symbol = NULL;

    13         symbol_c *last_type_symbol = NULL;

    14 

    14 

    15 		{

    15         {

    16 			identifier_c param_name("IN");

    16             identifier_c param_name("IN");

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

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

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

    19 			

    19             

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

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

    21 			if (IN_param_value == NULL)

    21             if (IN_param_value == NULL)

    22 			  IN_param_value = function_call_param_iterator.next();

    22               IN_param_value = function_call_param_iterator.next();

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

    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 ;

    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 			

    25             

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

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

    27 			{

    27             {

    28 		

    28         

    29 				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

    29                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

    30 				s4o.print("(");

    30                 s4o.print("(");

    31 				return_type_symbol->accept(*this);

    31                 return_type_symbol->accept(*this);

    32 				s4o.print(")");

    32                 s4o.print(")");

    33 				IN_param_value->accept(*this);

    33                 IN_param_value->accept(*this);

    34 				return NULL;

    34                 return NULL;

    35 				

    35                 

    36 			}

    36             }

    37 			

    37             

    38 			ERROR;

    38             ERROR;

    39 		}

    39         }

    40 		

    40         

    41 	}/*function_real_to_real*/

    41     }/*function_real_to_lreal*/

    42 	break;

    42     break;

    47 	case function_real_to_sint :

    47     case function_real_to_sint :

    48 	{

    48     {

    49 		symbol_c *last_type_symbol = NULL;

    49         symbol_c *last_type_symbol = NULL;

    50 

    50 

    51 		{

    51         {

    52 			identifier_c param_name("IN");

    52             identifier_c param_name("IN");

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

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

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

    55 			

    55             

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

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

    57 			if (IN_param_value == NULL)

    57             if (IN_param_value == NULL)

    58 			  IN_param_value = function_call_param_iterator.next();

    58               IN_param_value = function_call_param_iterator.next();

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

    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 ;

    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 			

    61             

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

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

    63 			{

    63             {

    64 		

    64         

    65 				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    65                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    66 				s4o.print("(");

    66                 s4o.print("(");

    67 				return_type_symbol->accept(*this);

    67                 return_type_symbol->accept(*this);

    68 				s4o.print(")");

    68                 s4o.print(")");

    69 				IN_param_value->accept(*this);

    69                 IN_param_value->accept(*this);

    70 				return NULL;

    70                 return NULL;

    71 				

    71                 

    72 			}

    72             }

    73 			

    73             

    74 			ERROR;

    74             ERROR;

    75 		}

    75         }

    76 		

    76         

    77 	}/*function_real_to_sint*/

    77     }/*function_real_to_sint*/

    78 	break;

    78     break;

    79 

    80 /****

    81  *REAL_TO_INT

    82  */

    83     case function_real_to_int :

    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::int_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_int*/

   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;

    83 	case function_real_to_lint :

   155     case function_real_to_lint :

    84 	{

   156     {

    85 		symbol_c *last_type_symbol = NULL;

   157         symbol_c *last_type_symbol = NULL;

    86 

   158 

    87 		{

   159         {

    88 			identifier_c param_name("IN");

   160             identifier_c param_name("IN");

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

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

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

    91 			

   163             

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

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

    93 			if (IN_param_value == NULL)

   165             if (IN_param_value == NULL)

    94 			  IN_param_value = function_call_param_iterator.next();

   166               IN_param_value = function_call_param_iterator.next();

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

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

   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 ;

    97 			

   169             

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

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

    99 			{

   171             {

   100 		

   172         

   101 				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   173                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   102 				s4o.print("(");

   174                 s4o.print("(");

   103 				return_type_symbol->accept(*this);

   175                 return_type_symbol->accept(*this);

   104 				s4o.print(")");

   176                 s4o.print(")");

   105 				IN_param_value->accept(*this);

   177                 IN_param_value->accept(*this);

   106 				return NULL;

   178                 return NULL;

   107 				

   179                 

   108 			}

   180             }

   109 			

   181             

   110 			ERROR;

   182             ERROR;

   111 		}

   183         }

   112 		

   184         

   113 	}/*function_real_to_lint*/

   185     }/*function_real_to_lint*/

   114 	break;

   186     break;

   115 

   187 

   116 /****

   188 /****

   117  *REAL_TO_DINT

   189  *REAL_TO_USINT

   118  */

   190  */

   119 	case function_real_to_dint :

   191     case function_real_to_usint :

   120 	{

   192     {

   121 		symbol_c *last_type_symbol = NULL;

   193         symbol_c *last_type_symbol = NULL;

   122 

   194 

   123 		{

   195         {

   124 			identifier_c param_name("IN");

   196             identifier_c param_name("IN");

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

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

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

   127 			

   199             

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

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

   129 			if (IN_param_value == NULL)

   201             if (IN_param_value == NULL)

   130 			  IN_param_value = function_call_param_iterator.next();

   202               IN_param_value = function_call_param_iterator.next();

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

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

   204             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 			

   205             

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

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

   135 			{

   207             {

   136 		

   208         

   137 				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   209                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   138 				s4o.print("(");

   210                 s4o.print("(");

   139 				return_type_symbol->accept(*this);

   211                 return_type_symbol->accept(*this);

   140 				s4o.print(")");

   212                 s4o.print(")");

   141 				IN_param_value->accept(*this);

   213                 IN_param_value->accept(*this);

   142 				return NULL;

   214                 return NULL;

   143 				

   215                 

   144 			}

   216             }

   145 			

   217             

   146 			ERROR;

   218             ERROR;

   147 		}

   219         }

   148 		

   220         

   149 	}/*function_real_to_dint*/

   221     }/*function_real_to_usint*/

   150 	break;

   222     break;

   223 

   224 /****

   225  *REAL_TO_UINT

   226  */

   227     case function_real_to_uint :

   228     {

   229         symbol_c *last_type_symbol = NULL;

   230 

   231         {

   232             identifier_c param_name("IN");

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

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

   235             

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

   237             if (IN_param_value == NULL)

   238               IN_param_value = function_call_param_iterator.next();

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

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

   241             

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

   243             {

   244         

   245                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   246                 s4o.print("(");

   247                 return_type_symbol->accept(*this);

   248                 s4o.print(")");

   249                 IN_param_value->accept(*this);

   250                 return NULL;

   251                 

   252             }

   253             

   254             ERROR;

   255         }

   256         

   257     }/*function_real_to_uint*/

   258     break;

   259 

   260 /****

   261  *REAL_TO_UDINT

   262  */

   263     case function_real_to_udint :

   264     {

   265         symbol_c *last_type_symbol = NULL;

   266 

   267         {

   268             identifier_c param_name("IN");

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

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

   271             

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

   273             if (IN_param_value == NULL)

   274               IN_param_value = function_call_param_iterator.next();

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

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

   277             

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

   279             {

   280         

   281                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   282                 s4o.print("(");

   283                 return_type_symbol->accept(*this);

   284                 s4o.print(")");

   285                 IN_param_value->accept(*this);

   286                 return NULL;

   287                 

   288             }

   289             

   290             ERROR;

   291         }

   292         

   293     }/*function_real_to_udint*/

   294     break;

   295 

   296 /****

   297  *REAL_TO_ULINT

   298  */

   299     case function_real_to_ulint :

   300     {

   301         symbol_c *last_type_symbol = NULL;

   302 

   303         {

   304             identifier_c param_name("IN");

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

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

   307             

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

   309             if (IN_param_value == NULL)

   310               IN_param_value = function_call_param_iterator.next();

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

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

   313             

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

   315             {

   316         

   317                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   318                 s4o.print("(");

   319                 return_type_symbol->accept(*this);

   320                 s4o.print(")");

   321                 IN_param_value->accept(*this);

   322                 return NULL;

   323                 

   324             }

   325             

   326             ERROR;

   327         }

   328         

   329     }/*function_real_to_ulint*/

   330     break;

   331 

   332 /****

   333  *REAL_TO_TIME

   334  */

   335     case function_real_to_time :

   336     {

   337         symbol_c *last_type_symbol = NULL;

   338 

   339         {

   340             identifier_c param_name("IN");

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

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

   343             

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

   345             if (IN_param_value == NULL)

   346               IN_param_value = function_call_param_iterator.next();

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

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

   349             

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

   351             {

   352         

   353                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   354                 s4o.print("(");

   355                 return_type_symbol->accept(*this);

   356                 s4o.print(")real_to_time(");

   357                 IN_param_value->accept(*this);

   358                 s4o.print(")");

   359                 return NULL;

   360                 

   361             }

   362             

   363             ERROR;

   364         }

   365         

   366     }/*function_real_to_time*/

   367     break;

   368 

   369 /****

   370  *REAL_TO_BOOL

   371  */

   372     case function_real_to_bool :

   373     {

   374         symbol_c *last_type_symbol = NULL;

   375 

   376         {

   377             identifier_c param_name("IN");

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

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

   380             

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

   382             if (IN_param_value == NULL)

   383               IN_param_value = function_call_param_iterator.next();

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

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

   386             

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

   388             {

   389         

   390                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   391                 s4o.print("(");

   392                 return_type_symbol->accept(*this);

   393                 s4o.print(")");

   394                 IN_param_value->accept(*this);

   395                 return NULL;

   396                 

   397             }

   398             

   399             ERROR;

   400         }

   401         

   402     }/*function_real_to_bool*/

   403     break;

   404 

   405 /****

   406  *REAL_TO_BYTE

   407  */

   408     case function_real_to_byte :

   409     {

   410         symbol_c *last_type_symbol = NULL;

   411 

   412         {

   413             identifier_c param_name("IN");

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

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

   416             

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

   418             if (IN_param_value == NULL)

   419               IN_param_value = function_call_param_iterator.next();

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

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

   422             

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

   424             {

   425         

   426                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   427                 s4o.print("(");

   428                 return_type_symbol->accept(*this);

   429                 s4o.print(")");

   430                 IN_param_value->accept(*this);

   431                 return NULL;

   432                 

   433             }

   434             

   435             ERROR;

   436         }

   437         

   438     }/*function_real_to_byte*/

   439     break;

   440 

   441 /****

   442  *REAL_TO_WORD

   443  */

   444     case function_real_to_word :

   445     {

   446         symbol_c *last_type_symbol = NULL;

   447 

   448         {

   449             identifier_c param_name("IN");

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

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

   452             

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

   454             if (IN_param_value == NULL)

   455               IN_param_value = function_call_param_iterator.next();

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

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

   458             

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

   460             {

   461         

   462                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   463                 s4o.print("(");

   464                 return_type_symbol->accept(*this);

   465                 s4o.print(")");

   466                 IN_param_value->accept(*this);

   467                 return NULL;

   468                 

   469             }

   470             

   471             ERROR;

   472         }

   473         

   474     }/*function_real_to_word*/

   475     break;

   476 

   477 /****

   478  *REAL_TO_DWORD

   479  */

   480     case function_real_to_dword :

   481     {

   482         symbol_c *last_type_symbol = NULL;

   483 

   484         {

   485             identifier_c param_name("IN");

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

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

   488             

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

   490             if (IN_param_value == NULL)

   491               IN_param_value = function_call_param_iterator.next();

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

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

   494             

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

   496             {

   497         

   498                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   499                 s4o.print("(");

   500                 return_type_symbol->accept(*this);

   501                 s4o.print(")");

   502                 IN_param_value->accept(*this);

   503                 return NULL;

   504                 

   505             }

   506             

   507             ERROR;

   508         }

   509         

   510     }/*function_real_to_dword*/

   511     break;

   512 

   513 /****

   514  *REAL_TO_LWORD

   515  */

   516     case function_real_to_lword :

   517     {

   518         symbol_c *last_type_symbol = NULL;

   519 

   520         {

   521             identifier_c param_name("IN");

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

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

   524             

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

   526             if (IN_param_value == NULL)

   527               IN_param_value = function_call_param_iterator.next();

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

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

   530             

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

   532             {

   533         

   534                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   535                 s4o.print("(");

   536                 return_type_symbol->accept(*this);

   537                 s4o.print(")");

   538                 IN_param_value->accept(*this);

   539                 return NULL;

   540                 

   541             }

   542             

   543             ERROR;

   544         }

   545         

   546     }/*function_real_to_lword*/

   547     break;

   548 

   549 /****

   550  *REAL_TO_STRING

   551  */

   552     case function_real_to_string :

   553     {

   554         symbol_c *last_type_symbol = NULL;

   555 

   556         {

   557             identifier_c param_name("IN");

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

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

   560             

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

   562             if (IN_param_value == NULL)

   563               IN_param_value = function_call_param_iterator.next();

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

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

   566             

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

   568             {

   569         

   570                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   571                 s4o.print("(");

   572                 return_type_symbol->accept(*this);

   573                 s4o.print(")int_to_string(");

   574                 IN_param_value->accept(*this);

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

   576                 return NULL;

   577                 

   578             }

   579             

   580             ERROR;

   581         }

   582         

   583     }/*function_real_to_string*/

   584     break;

   585 

   586 /****

   587  *REAL_TO_WSTRING

   588  */

   589     case function_real_to_wstring :

   590     {

   591         symbol_c *last_type_symbol = NULL;

   592 

   593         {

   594             identifier_c param_name("IN");

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

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

   597             

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

   599             if (IN_param_value == NULL)

   600               IN_param_value = function_call_param_iterator.next();

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

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

   603             

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

   605             {

   606         

   607                 symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;

   608                 s4o.print("(");

   609                 return_type_symbol->accept(*this);

   610                 s4o.print(")int_to_string(");

   611                 IN_param_value->accept(*this);

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

   613                 return NULL;

   614                 

   615             }

   616             

   617             ERROR;

   618         }

   619         

   620     }/*function_real_to_wstring*/

   621     break;

   155 	case function_real_to_date :

   626     case function_real_to_date :

   156 	{

   627     {

   157 		symbol_c *last_type_symbol = NULL;

   628         symbol_c *last_type_symbol = NULL;

   158 

   629 

   159 		{

   630         {

   160 			identifier_c param_name("IN");

   631             identifier_c param_name("IN");

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

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

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

   163 			

   634             

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

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

   165 			if (IN_param_value == NULL)

   636             if (IN_param_value == NULL)

   166 			  IN_param_value = function_call_param_iterator.next();

   637               IN_param_value = function_call_param_iterator.next();

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

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

   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 ;

   169 			

   640             

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

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

   171 			{

   642             {

   172 		

   643         

   173 				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   644                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   174 				s4o.print("(");

   645                 s4o.print("(");

   175 				return_type_symbol->accept(*this);

   646                 return_type_symbol->accept(*this);

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

   647                 s4o.print(")real_to_time(");

   177 				IN_param_value->accept(*this);

   648                 IN_param_value->accept(*this);

   178 				s4o.print(")");

   649                 s4o.print(")");

   179 				return NULL;

   650                 return NULL;

   180 				

   651                 

   181 			}

   652             }

   182 			

   653             

   183 			ERROR;

   654             ERROR;

   184 		}

   655         }

   185 		

   656         

   186 	}/*function_real_to_date*/

   657     }/*function_real_to_date*/

   187 	break;

   658     break;

   188 

   659 

   189 /****

   660 /****

   190  *REAL_TO_DWORD

   661  *REAL_TO_TOD

   191  */

   662  */

   192 	case function_real_to_dword :

   663     case function_real_to_tod :

   193 	{

   664     {

   194 		symbol_c *last_type_symbol = NULL;

   665         symbol_c *last_type_symbol = NULL;

   195 

   666 

   196 		{

   667         {

   197 			identifier_c param_name("IN");

   668             identifier_c param_name("IN");

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

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

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

   200 			

   671             

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

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

   202 			if (IN_param_value == NULL)

   673             if (IN_param_value == NULL)

   203 			  IN_param_value = function_call_param_iterator.next();

   674               IN_param_value = function_call_param_iterator.next();

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

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

   676             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 			

   677             

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

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

   208 			{

   679             {

   209 		

   680         

   210 				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   681                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   211 				s4o.print("(");

   682                 s4o.print("(");

   212 				return_type_symbol->accept(*this);

   683                 return_type_symbol->accept(*this);

   213 				s4o.print(")");

   684                 s4o.print(")real_to_time(");

   214 				IN_param_value->accept(*this);

   685                 IN_param_value->accept(*this);

   215 				return NULL;

   686                 s4o.print(")");

   216 				

   687                 return NULL;

   217 			}

   688                 

   218 			

   689             }

   219 			ERROR;

   690             

   220 		}

   691             ERROR;

   221 		

   692         }

   222 	}/*function_real_to_dword*/

   693         

   223 	break;

   694     }/*function_real_to_tod*/

   695     break;

   228 	case function_real_to_dt :

   700     case function_real_to_dt :

   229 	{

   701     {

   230 		symbol_c *last_type_symbol = NULL;

   702         symbol_c *last_type_symbol = NULL;

   231 

   703 

   232 		{

   704         {

   233 			identifier_c param_name("IN");

   705             identifier_c param_name("IN");

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

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

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

   236 			

   708             

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

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

   238 			if (IN_param_value == NULL)

   710             if (IN_param_value == NULL)

   239 			  IN_param_value = function_call_param_iterator.next();

   711               IN_param_value = function_call_param_iterator.next();

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

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

   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 ;

   242 			

   714             

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

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

   244 			{

   716             {

   245 		

   717         

   246 				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   718                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   247 				s4o.print("(");

   719                 s4o.print("(");

   248 				return_type_symbol->accept(*this);

   720                 return_type_symbol->accept(*this);

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

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

   250 				IN_param_value->accept(*this);

   722                 IN_param_value->accept(*this);

   251 				s4o.print(")");

   723                 s4o.print(")");

   252 				return NULL;

   724                 return NULL;

   253 				

   725                 

   254 			}

   726             }

   255 			

   727             

   256 			ERROR;

   728             ERROR;

   257 		}

   729         }

   258 		

   730         

   259 	}/*function_real_to_dt*/

   731     }/*function_real_to_dt*/

   260 	break;

   732     break;

   261 

   733 

   262 /****

   734 /****

   263  *REAL_TO_TOD

   735  *LREAL_TO_REAL

   264  */

   736  */

   265 	case function_real_to_tod :

   737     case function_lreal_to_real :

   266 	{

   738     {

   267 		symbol_c *last_type_symbol = NULL;

   739         symbol_c *last_type_symbol = NULL;

   268 

   740 

   269 		{

   741         {

   270 			identifier_c param_name("IN");

   742             identifier_c param_name("IN");

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

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

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

   273 			

   745             

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

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

   275 			if (IN_param_value == NULL)

   747             if (IN_param_value == NULL)

   276 			  IN_param_value = function_call_param_iterator.next();

   748               IN_param_value = function_call_param_iterator.next();

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

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

   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 ;

   279 			

   751             

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

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

   281 			{

   753             {

   282 		

   754         

   283 				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   755                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   284 				s4o.print("(");

   756                 s4o.print("(");

   285 				return_type_symbol->accept(*this);

   757                 return_type_symbol->accept(*this);

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

   758                 s4o.print(")");

   287 				IN_param_value->accept(*this);

   759                 IN_param_value->accept(*this);

   288 				s4o.print(")");

   760                 return NULL;

   289 				return NULL;

   761                 

   290 				

   762             }

   291 			}

   763             

   292 			

   764             ERROR;

   293 			ERROR;

   765         }

   294 		}

   766         

   295 		

   767     }/*function_lreal_to_real*/

   296 	}/*function_real_to_tod*/

   768     break;

   297 	break;

   769 

   298 

   770 /****

   299 /****

   771  *LREAL_TO_SINT

   300  *REAL_TO_UDINT

   772  */

   301  */

   773     case function_lreal_to_sint :

   302 	case function_real_to_udint :

   774     {

   303 	{

   775         symbol_c *last_type_symbol = NULL;

   304 		symbol_c *last_type_symbol = NULL;

   776 

   305 

   777         {

   306 		{

   778             identifier_c param_name("IN");

   307 			identifier_c param_name("IN");

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

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

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

   781             

   310 			

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

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

   783             if (IN_param_value == NULL)

   312 			if (IN_param_value == NULL)

   784               IN_param_value = function_call_param_iterator.next();

   313 			  IN_param_value = function_call_param_iterator.next();

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

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

   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 ;

   787             

   316 			

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

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

   789             {

   318 			{

   790         

   319 		

   791                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

   320 				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   792                 s4o.print("(");

   321 				s4o.print("(");

   793                 return_type_symbol->accept(*this);

   322 				return_type_symbol->accept(*this);

   794                 s4o.print(")");

   323 				s4o.print(")");

   795                 IN_param_value->accept(*this);

   324 				IN_param_value->accept(*this);

   796                 return NULL;

   325 				return NULL;

   797                 

   326 				

   798             }

   327 			}

   799             

   328 			

   800             ERROR;

   329 			ERROR;

   801         }

   330 		}

   802         

   331 		

   803     }/*function_lreal_to_sint*/

   332 	}/*function_real_to_udint*/

   804     break;

   333 	break;

   805 

   334 

   806 /****

   335 /****

   807  *LREAL_TO_INT

   336  *REAL_TO_WORD

   808  */

   337  */

   809     case function_lreal_to_int :

   338 	case function_real_to_word :

   810     {

   339 	{

   811         symbol_c *last_type_symbol = NULL;

   340 		symbol_c *last_type_symbol = NULL;

   812 

   341 

   813         {

   342 		{

   814             identifier_c param_name("IN");

   343 			identifier_c param_name("IN");

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

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

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

   817             

   346 			

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

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

   819             if (IN_param_value == NULL)

   348 			if (IN_param_value == NULL)

   820               IN_param_value = function_call_param_iterator.next();

   349 			  IN_param_value = function_call_param_iterator.next();

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

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

   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 ;

   823             

   352 			

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

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

   825             {

   354 			{

   826         

   355 		

   827                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   356 				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   828                 s4o.print("(");

   357 				s4o.print("(");

   829                 return_type_symbol->accept(*this);

   358 				return_type_symbol->accept(*this);

   830                 s4o.print(")");

   359 				s4o.print(")");

   831                 IN_param_value->accept(*this);

   360 				IN_param_value->accept(*this);

   832                 return NULL;

   361 				return NULL;

   833                 

   362 				

   834             }

   363 			}

   835             

   364 			

   836             ERROR;

   365 			ERROR;

   837         }

   366 		}

   838         

   367 		

   839     }/*function_lreal_to_int*/

   368 	}/*function_real_to_word*/

   840     break;

   369 	break;

   841 

   370 

   842 /****

   371 /****

   843  *LREAL_TO_DINT

   372  *REAL_TO_WSTRING

   844  */

   373  */

   845     case function_lreal_to_dint :

   374 	case function_real_to_wstring :

   846     {

   375 	{

   847         symbol_c *last_type_symbol = NULL;

   376 		symbol_c *last_type_symbol = NULL;

   848 

   377 

   849         {

   378 		{

   850             identifier_c param_name("IN");

   379 			identifier_c param_name("IN");

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

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

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

   853             

   382 			

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

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

   855             if (IN_param_value == NULL)

   384 			if (IN_param_value == NULL)

   856               IN_param_value = function_call_param_iterator.next();

   385 			  IN_param_value = function_call_param_iterator.next();

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

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

   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 ;

   859             

   388 			

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

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

   861             {

   390 			{

   862         

   391 		

   863                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   392 				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;

   864                 s4o.print("(");

   393 				s4o.print("(");

   865                 return_type_symbol->accept(*this);

   394 				return_type_symbol->accept(*this);

   866                 s4o.print(")");

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

   867                 IN_param_value->accept(*this);

   396 				IN_param_value->accept(*this);

   868                 return NULL;

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

   869                 

   398 				return NULL;

   870             }

   399 				

   871             

   400 			}

   872             ERROR;

   401 			

   873         }

   402 			ERROR;

   874         

   403 		}

   875     }/*function_lreal_to_dint*/

   404 		

   876     break;

   405 	}/*function_real_to_wstring*/

   877 

   406 	break;

   878 /****

   407 

   879  *LREAL_TO_LINT

   408 /****

   880  */

   409  *REAL_TO_STRING

   881     case function_lreal_to_lint :

   410  */

   882     {

   411 	case function_real_to_string :

   883         symbol_c *last_type_symbol = NULL;

   412 	{

   884 

   413 		symbol_c *last_type_symbol = NULL;

   885         {

   414 

   886             identifier_c param_name("IN");

   415 		{

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

   416 			identifier_c param_name("IN");

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

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

   889             

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

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

   419 			

   891             if (IN_param_value == NULL)

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

   892               IN_param_value = function_call_param_iterator.next();

   421 			if (IN_param_value == NULL)

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

   422 			  IN_param_value = function_call_param_iterator.next();

   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 ;

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

   895             

   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 ;

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

   425 			

   897             {

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

   898         

   427 			{

   899                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   428 		

   900                 s4o.print("(");

   429 				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   901                 return_type_symbol->accept(*this);

   430 				s4o.print("(");

   902                 s4o.print(")");

   431 				return_type_symbol->accept(*this);

   903                 IN_param_value->accept(*this);

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

   904                 return NULL;

   433 				IN_param_value->accept(*this);

   905                 

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

   906             }

   435 				return NULL;

   907             

   436 				

   908             ERROR;

   437 			}

   909         }

   438 			

   910         

   439 			ERROR;

   911     }/*function_lreal_to_lint*/

   440 		}

   912     break;

   441 		

   913 

   442 	}/*function_real_to_string*/

   914 /****

   443 	break;

   915  *LREAL_TO_USINT

   444 

   916  */

   445 /****

   917     case function_lreal_to_usint :

   446  *REAL_TO_LWORD

   918     {

   447  */

   919         symbol_c *last_type_symbol = NULL;

   448 	case function_real_to_lword :

   920 

   449 	{

   921         {

   450 		symbol_c *last_type_symbol = NULL;

   922             identifier_c param_name("IN");

   451 

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

   452 		{

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

   453 			identifier_c param_name("IN");

   925             

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

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

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

   927             if (IN_param_value == NULL)

   456 			

   928               IN_param_value = function_call_param_iterator.next();

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

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

   458 			if (IN_param_value == NULL)

   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 ;

   459 			  IN_param_value = function_call_param_iterator.next();

   931             

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

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

   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 ;

   933             {

   462 			

   934         

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

   935                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   464 			{

   936                 s4o.print("(");

   465 		

   937                 return_type_symbol->accept(*this);

   466 				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   938                 s4o.print(")");

   467 				s4o.print("(");

   939                 IN_param_value->accept(*this);

   468 				return_type_symbol->accept(*this);

   940                 return NULL;

   469 				s4o.print(")");

   941                 

   470 				IN_param_value->accept(*this);

   942             }

   471 				return NULL;

   943             

   472 				

   944             ERROR;

   473 			}

   945         }

   474 			

   946         

   475 			ERROR;

   947     }/*function_lreal_to_usint*/

   476 		}

   948     break;

   477 		

   949 

   478 	}/*function_real_to_lword*/

   950 /****

   479 	break;

   951  *LREAL_TO_UINT

   480 

   952  */

   481 /****

   953     case function_lreal_to_uint :

   482  *REAL_TO_UINT

   954     {

   483  */

   955         symbol_c *last_type_symbol = NULL;

   484 	case function_real_to_uint :

   956 

   485 	{

   957         {

   486 		symbol_c *last_type_symbol = NULL;

   958             identifier_c param_name("IN");

   487 

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

   488 		{

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

   489 			identifier_c param_name("IN");

   961             

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

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

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

   963             if (IN_param_value == NULL)

   492 			

   964               IN_param_value = function_call_param_iterator.next();

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

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

   494 			if (IN_param_value == NULL)

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

   495 			  IN_param_value = function_call_param_iterator.next();

   967             

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

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

   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 ;

   969             {

   498 			

   970         

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

   971                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   500 			{

   972                 s4o.print("(");

   501 		

   973                 return_type_symbol->accept(*this);

   502 				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   974                 s4o.print(")");

   503 				s4o.print("(");

   975                 IN_param_value->accept(*this);

   504 				return_type_symbol->accept(*this);

   976                 return NULL;

   505 				s4o.print(")");

   977                 

   506 				IN_param_value->accept(*this);

   978             }

   507 				return NULL;

   979             

   508 				

   980             ERROR;

   509 			}

   981         }

   510 			

   982         

   511 			ERROR;

   983     }/*function_lreal_to_uint*/

   512 		}

   984     break;

   513 		

   985 

   514 	}/*function_real_to_uint*/

   986 /****

   515 	break;

   987  *LREAL_TO_UDINT

   516 

   988  */

   517 /****

   989     case function_lreal_to_udint :

   518  *REAL_TO_LREAL

   990     {

   519  */

   991         symbol_c *last_type_symbol = NULL;

   520 	case function_real_to_lreal :

   992 

   521 	{

   993         {

   522 		symbol_c *last_type_symbol = NULL;

   994             identifier_c param_name("IN");

   523 

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

   524 		{

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

   525 			identifier_c param_name("IN");

   997             

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

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

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

   999             if (IN_param_value == NULL)

   528 			

  1000               IN_param_value = function_call_param_iterator.next();

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

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

   530 			if (IN_param_value == NULL)

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

   531 			  IN_param_value = function_call_param_iterator.next();

  1003             

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

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

   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 ;

  1005             {

   534 			

  1006         

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

  1007                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   536 			{

  1008                 s4o.print("(");

   537 		

  1009                 return_type_symbol->accept(*this);

   538 				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

  1010                 s4o.print(")");

   539 				s4o.print("(");

  1011                 IN_param_value->accept(*this);

   540 				return_type_symbol->accept(*this);

  1012                 return NULL;

   541 				s4o.print(")");

  1013                 

   542 				IN_param_value->accept(*this);

  1014             }

   543 				return NULL;

  1015             

   544 				

  1016             ERROR;

   545 			}

  1017         }

   546 			

  1018         

   547 			ERROR;

  1019     }/*function_lreal_to_udint*/

   548 		}

  1020     break;

   549 		

  1021 

   550 	}/*function_real_to_lreal*/

  1022 /****

   551 	break;

  1023  *LREAL_TO_ULINT

   552 

  1024  */

   553 /****

  1025     case function_lreal_to_ulint :

   554  *REAL_TO_BYTE

  1026     {

   555  */

  1027         symbol_c *last_type_symbol = NULL;

   556 	case function_real_to_byte :

  1028 

   557 	{

  1029         {

   558 		symbol_c *last_type_symbol = NULL;

  1030             identifier_c param_name("IN");

   559 

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

   560 		{

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

   561 			identifier_c param_name("IN");

  1033             

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

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

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

  1035             if (IN_param_value == NULL)

   564 			

  1036               IN_param_value = function_call_param_iterator.next();

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

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

   566 			if (IN_param_value == NULL)

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

   567 			  IN_param_value = function_call_param_iterator.next();

  1039             

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

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

   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 ;

  1041             {

   570 			

  1042         

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

  1043                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   572 			{

  1044                 s4o.print("(");

   573 		

  1045                 return_type_symbol->accept(*this);

   574 				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

  1046                 s4o.print(")");

   575 				s4o.print("(");

  1047                 IN_param_value->accept(*this);

   576 				return_type_symbol->accept(*this);

  1048                 return NULL;

   577 				s4o.print(")");

  1049                 

   578 				IN_param_value->accept(*this);

  1050             }

   579 				return NULL;

  1051             

   580 				

  1052             ERROR;

   581 			}

  1053         }

   582 			

  1054         

   583 			ERROR;

  1055     }/*function_lreal_to_ulint*/

   584 		}

  1056     break;

   585 		

  1057 

   586 	}/*function_real_to_byte*/

  1058 /****

   587 	break;

  1059  *LREAL_TO_TIME

   588 

  1060  */

   589 /****

  1061     case function_lreal_to_time :

   590  *REAL_TO_USINT

  1062     {

   591  */

  1063         symbol_c *last_type_symbol = NULL;

   592 	case function_real_to_usint :

  1064 

   593 	{

  1065         {

   594 		symbol_c *last_type_symbol = NULL;

  1066             identifier_c param_name("IN");

   595 

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

   596 		{

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

   597 			identifier_c param_name("IN");

  1069             

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

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

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

  1071             if (IN_param_value == NULL)

   600 			

  1072               IN_param_value = function_call_param_iterator.next();

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

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

   602 			if (IN_param_value == NULL)

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

   603 			  IN_param_value = function_call_param_iterator.next();

  1075             

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

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

   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 ;

  1077             {

   606 			

  1078         

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

  1079                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   608 			{

  1080                 s4o.print("(");

   609 		

  1081                 return_type_symbol->accept(*this);

   610 				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

  1082                 s4o.print(")real_to_time(");

   611 				s4o.print("(");

  1083                 IN_param_value->accept(*this);

   612 				return_type_symbol->accept(*this);

  1084                 s4o.print(")");

   613 				s4o.print(")");

  1085                 return NULL;

   614 				IN_param_value->accept(*this);

  1086                 

   615 				return NULL;

  1087             }

   616 				

  1088             

   617 			}

  1089             ERROR;

   618 			

  1090         }

   619 			ERROR;

  1091         

   620 		}

  1092     }/*function_lreal_to_time*/

   621 		

  1093     break;

   622 	}/*function_real_to_usint*/

  1094 

   623 	break;

  1095 /****

   624 

  1096  *LREAL_TO_BOOL

   625 /****

  1097  */

   626  *REAL_TO_ULINT

  1098     case function_lreal_to_bool :

   627  */

  1099     {

   628 	case function_real_to_ulint :

  1100         symbol_c *last_type_symbol = NULL;

   629 	{

  1101 

   630 		symbol_c *last_type_symbol = NULL;

  1102         {

   631 

  1103             identifier_c param_name("IN");

   632 		{

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

   633 			identifier_c param_name("IN");

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

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

  1106             

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

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

   636 			

  1108             if (IN_param_value == NULL)

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

  1109               IN_param_value = function_call_param_iterator.next();

   638 			if (IN_param_value == NULL)

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

   639 			  IN_param_value = function_call_param_iterator.next();

  1111             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 			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1112             

   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 ;

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

   642 			

  1114             {

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

  1115         

   644 			{

  1116                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   645 		

  1117                 s4o.print("(");

   646 				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

  1118                 return_type_symbol->accept(*this);

   647 				s4o.print("(");

  1119                 s4o.print(")");

   648 				return_type_symbol->accept(*this);

  1120                 IN_param_value->accept(*this);

   649 				s4o.print(")");

  1121                 return NULL;

   650 				IN_param_value->accept(*this);

  1122                 

   651 				return NULL;

  1123             }

   652 				

  1124             

   653 			}

  1125             ERROR;

   654 			

  1126         }

   655 			ERROR;

  1127         

   656 		}

  1128     }/*function_lreal_to_bool*/

   657 		

  1129     break;

   658 	}/*function_real_to_ulint*/

  1130 

   659 	break;

  1131 /****

   660 

  1132  *LREAL_TO_BYTE

   661 /****

  1133  */

   662  *REAL_TO_BOOL

  1134     case function_lreal_to_byte :

   663  */

  1135     {

   664 	case function_real_to_bool :

  1136         symbol_c *last_type_symbol = NULL;

   665 	{

  1137 

   666 		symbol_c *last_type_symbol = NULL;

  1138         {

   667