24 

    25 /****

    26  * IEC 61131-3 standard function library

    27  * generated code, do not edit by hand

    28  */

    34  *REAL_TO_SINT

    35  */

    36     case function_real_to_sint :

    37     {

    38         symbol_c *last_type_symbol = NULL;

    39 

    40         {

    41             identifier_c param_name("IN");

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

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

    44             

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

    46             if (IN_param_value == NULL)

    47               IN_param_value = function_call_param_iterator.next();

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

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

    50             

    51             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

    52             {

    53         

    54                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

    55                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    56                 function_type_prefix = return_type_symbol;

    57                 break;

    58                 

    59             }

    60             

    61             

    62             ERROR;

    63         }

    64         

    65     }/*function_real_to_sint*/

    66     break;

    67 

    68 /****

    69  *REAL_TO_LINT

    70  */

    71     case function_real_to_lint :

    72     {

    73         symbol_c *last_type_symbol = NULL;

    74 

    75         {

    76             identifier_c param_name("IN");

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

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

    79             

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

    81             if (IN_param_value == NULL)

    82               IN_param_value = function_call_param_iterator.next();

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

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

    85             

    86             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

    87             {

    88         

    89                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

    90                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

    91                 function_type_prefix = return_type_symbol;

    92                 break;

    93                 

    94             }

    95             

    96             

    97             ERROR;

    98         }

    99         

   100     }/*function_real_to_lint*/

   101     break;

   102 

   103 /****

   104  *REAL_TO_DINT

   105  */

   106     case function_real_to_dint :

   107     {

   108         symbol_c *last_type_symbol = NULL;

   109 

   110         {

   111             identifier_c param_name("IN");

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

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

   114             

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

   116             if (IN_param_value == NULL)

   117               IN_param_value = function_call_param_iterator.next();

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

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

   120             

   121             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   122             {

   123         

   124                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   125                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   126                 function_type_prefix = return_type_symbol;

   127                 break;

   128                 

   129             }

   130             

   131             

   132             ERROR;

   133         }

   134         

   135     }/*function_real_to_dint*/

   136     break;

   137 

   138 /****

   139  *REAL_TO_DATE

   140  */

   141     case function_real_to_date :

   142     {

   143         symbol_c *last_type_symbol = NULL;

   144 

   145         {

   146             identifier_c param_name("IN");

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

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

   149             

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

   151             if (IN_param_value == NULL)

   152               IN_param_value = function_call_param_iterator.next();

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

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

   155             

   156             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   157             {

   158         

   159                 function_name = (symbol_c*)(new pragma_c("__real_to_time"));

   160                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   161                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   162                 function_type_prefix = return_type_symbol;

   163                 break;

   164                 

   165             }

   166             

   167             

   168             ERROR;

   169         }

   170         

   171     }/*function_real_to_date*/

   172     break;

   173 

   174 /****

   175  *REAL_TO_DWORD

   176  */

   177     case function_real_to_dword :

   178     {

   179         symbol_c *last_type_symbol = NULL;

   180 

   181         {

   182             identifier_c param_name("IN");

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

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

   185             

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

   187             if (IN_param_value == NULL)

   188               IN_param_value = function_call_param_iterator.next();

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

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

   191             

   192             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   193             {

   194         

   195                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   196                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   197                 function_type_prefix = return_type_symbol;

   198                 break;

   199                 

   200             }

   201             

   202             

   203             ERROR;

   204         }

   205         

   206     }/*function_real_to_dword*/

   207     break;

   208 

   209 /****

   210  *REAL_TO_DT

   211  */

   212     case function_real_to_dt :

   213     {

   214         symbol_c *last_type_symbol = NULL;

   215 

   216         {

   217             identifier_c param_name("IN");

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

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

   220             

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

   222             if (IN_param_value == NULL)

   223               IN_param_value = function_call_param_iterator.next();

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

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

   226             

   227             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   228             {

   229         

   230                 function_name = (symbol_c*)(new pragma_c("__real_to_time"));

   231                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   232                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   233                 function_type_prefix = return_type_symbol;

   234                 break;

   235                 

   236             }

   237             

   238             

   239             ERROR;

   240         }

   241         

   242     }/*function_real_to_dt*/

   243     break;

   244 

   245 /****

   246  *REAL_TO_TOD

   247  */

   248     case function_real_to_tod :

   249     {

   250         symbol_c *last_type_symbol = NULL;

   251 

   252         {

   253             identifier_c param_name("IN");

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

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

   256             

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

   258             if (IN_param_value == NULL)

   259               IN_param_value = function_call_param_iterator.next();

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

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

   262             

   263             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   264             {

   265         

   266                 function_name = (symbol_c*)(new pragma_c("__real_to_time"));

   267                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   268                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   269                 function_type_prefix = return_type_symbol;

   270                 break;

   271                 

   272             }

   273             

   274             

   275             ERROR;

   276         }

   277         

   278     }/*function_real_to_tod*/

   279     break;

   280 

   281 /****

   282  *REAL_TO_UDINT

   283  */

   284     case function_real_to_udint :

   285     {

   286         symbol_c *last_type_symbol = NULL;

   287 

   288         {

   289             identifier_c param_name("IN");

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

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

   292             

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

   294             if (IN_param_value == NULL)

   295               IN_param_value = function_call_param_iterator.next();

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

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

   298             

   299             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   300             {

   301         

   302                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   303                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   304                 function_type_prefix = return_type_symbol;

   305                 break;

   306                 

   307             }

   308             

   309             

   310             ERROR;

   311         }

   312         

   313     }/*function_real_to_udint*/

   314     break;

   315 

   316 /****

   317  *REAL_TO_WORD

   318  */

   319     case function_real_to_word :

   320     {

   321         symbol_c *last_type_symbol = NULL;

   322 

   323         {

   324             identifier_c param_name("IN");

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

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

   327             

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

   329             if (IN_param_value == NULL)

   330               IN_param_value = function_call_param_iterator.next();

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

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

   333             

   334             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   335             {

   336         

   337                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   338                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   339                 function_type_prefix = return_type_symbol;

   340                 break;

   341                 

   342             }

   343             

   344             

   345             ERROR;

   346         }

   347         

   348     }/*function_real_to_word*/

   349     break;

   350 

   351 /****

   352  *REAL_TO_STRING

   353  */

   354     case function_real_to_string :

   355     {

   356         symbol_c *last_type_symbol = NULL;

   357 

   358         {

   359             identifier_c param_name("IN");

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

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

   362             

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

   364             if (IN_param_value == NULL)

   365               IN_param_value = function_call_param_iterator.next();

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

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

   368             

   369             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   370             {

   371         

   372                 function_name = (symbol_c*)(new pragma_c("__real_to_string"));

   373                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   374                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   375                 function_type_prefix = return_type_symbol;

   376                 break;

   377                 

   378             }

   379             

   380             

   381             ERROR;

   382         }

   383         

   384     }/*function_real_to_string*/

   385     break;

   386 

   387 /****

   388  *REAL_TO_LWORD

   389  */

   390     case function_real_to_lword :

   391     {

   392         symbol_c *last_type_symbol = NULL;

   393 

   394         {

   395             identifier_c param_name("IN");

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

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

   398             

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

   400             if (IN_param_value == NULL)

   401               IN_param_value = function_call_param_iterator.next();

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

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

   404             

   405             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   406             {

   407         

   408                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   409                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   410                 function_type_prefix = return_type_symbol;

   411                 break;

   412                 

   413             }

   414             

   415             

   416             ERROR;

   417         }

   418         

   419     }/*function_real_to_lword*/

   420     break;

   421 

   422 /****

   423  *REAL_TO_UINT

   424  */

   425     case function_real_to_uint :

   426     {

   427         symbol_c *last_type_symbol = NULL;

   428 

   429         {

   430             identifier_c param_name("IN");

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

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

   433             

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

   435             if (IN_param_value == NULL)

   436               IN_param_value = function_call_param_iterator.next();

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

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

   439             

   440             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   441             {

   442         

   443                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   444                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   445                 function_type_prefix = return_type_symbol;

   446                 break;

   447                 

   448             }

   449             

   450             

   451             ERROR;

   452         }

   453         

   454     }/*function_real_to_uint*/

   455     break;

   456 

   457 /****

   458  *REAL_TO_LREAL

   459  */

   460     case function_real_to_lreal :

   461     {

   462         symbol_c *last_type_symbol = NULL;

   463 

   464         {

   465             identifier_c param_name("IN");

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

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

   468             

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

   470             if (IN_param_value == NULL)

   471               IN_param_value = function_call_param_iterator.next();

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

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

   474             

   475             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   476             {

   477         

   478                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   479                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   480                 function_type_prefix = return_type_symbol;

   481                 break;

   482                 

   483             }

   484             

   485             

   486             ERROR;

   487         }

   488         

   489     }/*function_real_to_lreal*/

   490     break;

   491 

   492 /****

   493  *REAL_TO_BYTE

   494  */

   495     case function_real_to_byte :

   496     {

   497         symbol_c *last_type_symbol = NULL;

   498 

   499         {

   500             identifier_c param_name("IN");

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

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

   503             

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

   505             if (IN_param_value == NULL)

   506               IN_param_value = function_call_param_iterator.next();

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

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

   509             

   510             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   511             {

   512         

   513                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   514                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   515                 function_type_prefix = return_type_symbol;

   516                 break;

   517                 

   518             }

   519             

   520             

   521             ERROR;

   522         }

   523         

   524     }/*function_real_to_byte*/

   525     break;

   526 

   527 /****

   528  *REAL_TO_USINT

   529  */

   530     case function_real_to_usint :

   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(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   546             {

   547         

   548                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   549                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   550                 function_type_prefix = return_type_symbol;

   551                 break;

   552                 

   553             }

   554             

   555             

   556             ERROR;

   557         }

   558         

   559     }/*function_real_to_usint*/

   560     break;

   561 

   562 /****

   563  *REAL_TO_ULINT

   564  */

   565     case function_real_to_ulint :

   566     {

   567         symbol_c *last_type_symbol = NULL;

   568 

   569         {

   570             identifier_c param_name("IN");

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

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

   573             

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

   575             if (IN_param_value == NULL)

   576               IN_param_value = function_call_param_iterator.next();

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

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

   579             

   580             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   581             {

   582         

   583                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   584                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   585                 function_type_prefix = return_type_symbol;

   586                 break;

   587                 

   588             }

   589             

   590             

   591             ERROR;

   592         }

   593         

   594     }/*function_real_to_ulint*/

   595     break;

   596 

   597 /****

   598  *REAL_TO_BOOL

   599  */

   600     case function_real_to_bool :

   601     {

   602         symbol_c *last_type_symbol = NULL;

   603 

   604         {

   605             identifier_c param_name("IN");

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

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

   608             

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

   610             if (IN_param_value == NULL)

   611               IN_param_value = function_call_param_iterator.next();

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

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

   614             

   615             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   616             {

   617         

   618                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   619                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   620                 function_type_prefix = return_type_symbol;

   621                 break;

   622                 

   623             }

   624             

   625             

   626             ERROR;

   627         }

   628         

   629     }/*function_real_to_bool*/

   630     break;

   631 

   632 /****

   633  *REAL_TO_TIME

   634  */

   635     case function_real_to_time :

   636     {

   637         symbol_c *last_type_symbol = NULL;

   638 

   639         {

   640             identifier_c param_name("IN");

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

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

   643             

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

   645             if (IN_param_value == NULL)

   646               IN_param_value = function_call_param_iterator.next();

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

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

   649             

   650             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   651             {

   652         

   653                 function_name = (symbol_c*)(new pragma_c("__real_to_time"));

   654                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   655                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   656                 function_type_prefix = return_type_symbol;

   657                 break;

   658                 

   659             }

   660             

   661             

   662             ERROR;

   663         }

   664         

   665     }/*function_real_to_time*/

   666     break;

   667 

   668 /****

   669  *REAL_TO_INT

   670  */

   671     case function_real_to_int :

   672     {

   673         symbol_c *last_type_symbol = NULL;

   674 

   675         {

   676             identifier_c param_name("IN");

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

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

   679             

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

   681             if (IN_param_value == NULL)

   682               IN_param_value = function_call_param_iterator.next();

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

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

   685             

   686             if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   687             {

   688         

   689                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   690                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   691                 function_type_prefix = return_type_symbol;

   692                 break;

   693                 

   694             }

   695             

   696             

   697             ERROR;

   698         }

   699         

   700     }/*function_real_to_int*/

   701     break;

   702 

   703 /****

   704  *SINT_TO_REAL

   705  */

   706     case function_sint_to_real :

   707     {

   708         symbol_c *last_type_symbol = NULL;

   709 

   710         {

   711             identifier_c param_name("IN");

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

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

   714             

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

   716             if (IN_param_value == NULL)

   717               IN_param_value = function_call_param_iterator.next();

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

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

   720             

   721             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   722             {

   723         

   724                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   725                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   726                 function_type_prefix = return_type_symbol;

   727                 break;

   728                 

   729             }

   730             

   731             

   732             ERROR;

   733         }

   734         

   735     }/*function_sint_to_real*/

   736     break;

   737 

   738 /****

   739  *SINT_TO_LINT

   740  */

   741     case function_sint_to_lint :

   742     {

   743         symbol_c *last_type_symbol = NULL;

   744 

   745         {

   746             identifier_c param_name("IN");

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

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

   749             

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

   751             if (IN_param_value == NULL)

   752               IN_param_value = function_call_param_iterator.next();

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

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

   755             

   756             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   757             {

   758         

   759                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   760                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   761                 function_type_prefix = return_type_symbol;

   762                 break;

   763                 

   764             }

   765             

   766             

   767             ERROR;

   768         }

   769         

   770     }/*function_sint_to_lint*/

   771     break;

   772 

   773 /****

   774  *SINT_TO_DINT

   775  */

   776     case function_sint_to_dint :

   777     {

   778         symbol_c *last_type_symbol = NULL;

   779 

   780         {

   781             identifier_c param_name("IN");

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

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

   784             

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

   786             if (IN_param_value == NULL)

   787               IN_param_value = function_call_param_iterator.next();

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

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

   790             

   791             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   792             {

   793         

   794                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   795                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   796                 function_type_prefix = return_type_symbol;

   797                 break;

   798                 

   799             }

   800             

   801             

   802             ERROR;

   803         }

   804         

   805     }/*function_sint_to_dint*/

   806     break;

   807 

   808 /****

   809  *SINT_TO_DATE

   810  */

   811     case function_sint_to_date :

   812     {

   813         symbol_c *last_type_symbol = NULL;

   814 

   815         {

   816             identifier_c param_name("IN");

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

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

   819             

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

   821             if (IN_param_value == NULL)

   822               IN_param_value = function_call_param_iterator.next();

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

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

   825             

   826             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   827             {

   828         

   829                 function_name = (symbol_c*)(new pragma_c("__int_to_time"));

   830                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   831                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   832                 function_type_prefix = return_type_symbol;

   833                 break;

   834                 

   835             }

   836             

   837             

   838             ERROR;

   839         }

   840         

   841     }/*function_sint_to_date*/

   842     break;

   843 

   844 /****

   845  *SINT_TO_DWORD

   846  */

   847     case function_sint_to_dword :

   848     {

   849         symbol_c *last_type_symbol = NULL;

   850 

   851         {

   852             identifier_c param_name("IN");

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

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

   855             

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

   857             if (IN_param_value == NULL)

   858               IN_param_value = function_call_param_iterator.next();

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

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

   861             

   862             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   863             {

   864         

   865                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   866                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   867                 function_type_prefix = return_type_symbol;

   868                 break;

   869                 

   870             }

   871             

   872             

   873             ERROR;

   874         }

   875         

   876     }/*function_sint_to_dword*/

   877     break;

   878 

   879 /****

   880  *SINT_TO_DT

   881  */

   882     case function_sint_to_dt :

   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(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   898             {

   899         

   900                 function_name = (symbol_c*)(new pragma_c("__int_to_time"));

   901                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   902                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   903                 function_type_prefix = return_type_symbol;

   904                 break;

   905                 

   906             }

   907             

   908             

   909             ERROR;

   910         }

   911         

   912     }/*function_sint_to_dt*/

   913     break;

   914 

   915 /****

   916  *SINT_TO_TOD

   917  */

   918     case function_sint_to_tod :

   919     {

   920         symbol_c *last_type_symbol = NULL;

   921 

   922         {

   923             identifier_c param_name("IN");

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

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

   926             

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

   928             if (IN_param_value == NULL)

   929               IN_param_value = function_call_param_iterator.next();

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

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

   932             

   933             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   934             {

   935         

   936                 function_name = (symbol_c*)(new pragma_c("__int_to_time"));

   937                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   938                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   939                 function_type_prefix = return_type_symbol;

   940                 break;

   941                 

   942             }

   943             

   944             

   945             ERROR;

   946         }

   947         

   948     }/*function_sint_to_tod*/

   949     break;

   950 

   951 /****

   952  *SINT_TO_UDINT

   953  */

   954     case function_sint_to_udint :

   955     {

   956         symbol_c *last_type_symbol = NULL;

   957 

   958         {

   959             identifier_c param_name("IN");

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

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

   962             

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

   964             if (IN_param_value == NULL)

   965               IN_param_value = function_call_param_iterator.next();

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

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

   968             

   969             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   970             {

   971         

   972                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   973                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   974                 function_type_prefix = return_type_symbol;

   975                 break;

   976                 

   977             }

   978             

   979             

   980             ERROR;

   981         }

   982         

   983     }/*function_sint_to_udint*/

   984     break;

   985 

   986 /****

   987  *SINT_TO_WORD

   988  */

   989     case function_sint_to_word :

   990     {

   991         symbol_c *last_type_symbol = NULL;

   992 

   993         {

   994             identifier_c param_name("IN");

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

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

   997             

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

   999             if (IN_param_value == NULL)

  1000               IN_param_value = function_call_param_iterator.next();

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

  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 ;

  1003             

  1004             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

  1005             {

  1006         

  1007                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

  1008                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

  1009                 function_type_prefix = return_type_symbol;

  1010                 break;

  1011                 

  1012             }

  1013             

  1014             

  1015             ERROR;

  1016         }

  1017         

  1018     }/*function_sint_to_word*/

  1019     break;

  1020 

  1021 /****

  1022  *SINT_TO_STRING

  1023  */

  1024     case function_sint_to_string :

  1025     {

  1026         symbol_c *last_type_symbol = NULL;

  1027 

  1028         {

  1029             identifier_c param_name("IN");

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

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

  1032             

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

  1034             if (IN_param_value == NULL)

  1035               IN_param_value = function_call_param_iterator.next();

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

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

  1038             

  1039             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

  1040             {

  1041         

  1042                 function_name = (symbol_c*)(new pragma_c("__sint_to_string"));

  1043                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

  1044                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

  1045                 function_type_prefix = return_type_symbol;

  1046                 break;

  1047                 

  1048             }

  1049             

  1050             

  1051             ERROR;

  1052         }

  1053         

  1054     }/*function_sint_to_string*/

  1055     break;

  1056 

  1057 /****

  1058  *SINT_TO_LWORD

  1059  */

  1060     case function_sint_to_lword :

  1061     {

  1062         symbol_c *last_type_symbol = NULL;

  1063 

  1064         {

  1065             identifier_c param_name("IN");

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

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

  1068             

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

  1070             if (IN_param_value == NULL)

  1071               IN_param_value = function_call_param_iterator.next();

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

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

  1074             

  1075             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

  1076             {

  1077         

  1078                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

  1079                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

  1080                 function_type_prefix = return_type_symbol;

  1081                 break;

  1082                 

  1083             }

  1084             

  1085             

  1086             ERROR;

  1087         }

  1088         

  1089     }/*function_sint_to_lword*/

  1090     break;

  1091 

  1092 /****

  1093  *SINT_TO_UINT

  1094  */

  1095     case function_sint_to_uint :

  1096     {

  1097         symbol_c *last_type_symbol = NULL;

  1098 

  1099         {

  1100             identifier_c param_name("IN");

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

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

  1103             

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

  1105             if (IN_param_value == NULL)

  1106               IN_param_value = function_call_param_iterator.next();

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

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

  1109             

  1110             if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

  1111             {

  1112         

  1113                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

  1114                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

  1115                 function_type_prefix = return_type_symbol;

  1116                 break;

  1117                 

  1118             }

  1119             

  1120             

  1121             ERROR;

  1122         }

  1123         

  1124     }/*function_sint_to_uint*/

  1125     break;

  1126 

  1127 /****

  1128  *SINT_TO_LREAL

  1129  */

  1130     case function_sint_to_lreal :

  1131     {

  1132         symbol_c *last_type_symbol = NULL;

  1133 

  1134         {

  1135             identifier_c param_name("IN");

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

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

  1138             

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

  1140             if (IN_param_value == NULL)

  1141               IN_param_value = function_call_param_iterator.next();

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