1 /*

     2  * Copyright (C) 2007-2011: Edouard TISSERANT and Laurent BESSARD

     3  *

     4  * See COPYING and COPYING.LESSER files for copyright details.

     5  *

     6  * This program is free software: you can redistribute it and/or modify

     7  * it under the terms of the GNU General Public License as published by

     8  * the Free Software Foundation, either version 3 of the License, or

     9  * (at your option) any later version.

    10  *

    11  * This program is distributed in the hope that it will be useful,

    12  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    14  * GNU General Public License for more details.

    15  *

    16  * You should have received a copy of the GNU General Public License

    17  * along with this program. If not, see <http://www.gnu.org/licenses/>.

    18  *

    19  */

    20 

    21 /****

    22  * IEC 61131-3 standard function library

    23  * generated code, do not edit by hand

    24  */

    25  

    26  

    27 switch(current_function_type){

    28 

    29 /****

    30  *REAL_TO_SINT

    31  */

    32     case function_real_to_sint :

    33     {

    34         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

    35 

    36         {

    37             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

    39             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

    40             symbol_c *IN_type_symbol = NULL;

    41             

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

    43             if (IN_param_value == NULL)

    44               IN_param_value = function_call_param_iterator.next_nf();

    45             if (IN_param_value != NULL) {

    46               IN_type_symbol = search_expression_type->get_type(IN_param_value);

    47               last_type_symbol = last_type_symbol && IN_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 ;

    48             }

    49             

    50             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

    51             {

    52         

    53                 function_name = (symbol_c*)(new pragma_c("__real_to_sint"));

    54                 

    55                 if (IN_type_symbol == NULL)

    56                   IN_type_symbol = last_type_symbol;

    57                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

    58                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    59                 function_type_prefix = return_type_symbol;

    60                 break;

    61                 

    62             }

    63             

    64             

    65             ERROR;

    66         }

    67         

    68     }/*function_real_to_sint*/

    69     break;

    70 

    71 /****

    72  *REAL_TO_LINT

    73  */

    74     case function_real_to_lint :

    75     {

    76         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

    77 

    78         {

    79             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

    81             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

    82             symbol_c *IN_type_symbol = NULL;

    83             

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

    85             if (IN_param_value == NULL)

    86               IN_param_value = function_call_param_iterator.next_nf();

    87             if (IN_param_value != NULL) {

    88               IN_type_symbol = search_expression_type->get_type(IN_param_value);

    89               last_type_symbol = last_type_symbol && IN_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 ;

    90             }

    91             

    92             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

    93             {

    94         

    95                 function_name = (symbol_c*)(new pragma_c("__real_to_sint"));

    96                 

    97                 if (IN_type_symbol == NULL)

    98                   IN_type_symbol = last_type_symbol;

    99                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   100                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   101                 function_type_prefix = return_type_symbol;

   102                 break;

   103                 

   104             }

   105             

   106             

   107             ERROR;

   108         }

   109         

   110     }/*function_real_to_lint*/

   111     break;

   112 

   113 /****

   114  *REAL_TO_DINT

   115  */

   116     case function_real_to_dint :

   117     {

   118         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   119 

   120         {

   121             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   123             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   124             symbol_c *IN_type_symbol = NULL;

   125             

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

   127             if (IN_param_value == NULL)

   128               IN_param_value = function_call_param_iterator.next_nf();

   129             if (IN_param_value != NULL) {

   130               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   131               last_type_symbol = last_type_symbol && IN_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 ;

   132             }

   133             

   134             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   135             {

   136         

   137                 function_name = (symbol_c*)(new pragma_c("__real_to_sint"));

   138                 

   139                 if (IN_type_symbol == NULL)

   140                   IN_type_symbol = last_type_symbol;

   141                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   142                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   143                 function_type_prefix = return_type_symbol;

   144                 break;

   145                 

   146             }

   147             

   148             

   149             ERROR;

   150         }

   151         

   152     }/*function_real_to_dint*/

   153     break;

   154 

   155 /****

   156  *REAL_TO_DATE

   157  */

   158     case function_real_to_date :

   159     {

   160         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   161 

   162         {

   163             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   165             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   166             symbol_c *IN_type_symbol = NULL;

   167             

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

   169             if (IN_param_value == NULL)

   170               IN_param_value = function_call_param_iterator.next_nf();

   171             if (IN_param_value != NULL) {

   172               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   173               last_type_symbol = last_type_symbol && IN_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 ;

   174             }

   175             

   176             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   177             {

   178         

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

   180                 

   181                 if (IN_type_symbol == NULL)

   182                   IN_type_symbol = last_type_symbol;

   183                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   184                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   185                 function_type_prefix = return_type_symbol;

   186                 break;

   187                 

   188             }

   189             

   190             

   191             ERROR;

   192         }

   193         

   194     }/*function_real_to_date*/

   195     break;

   196 

   197 /****

   198  *REAL_TO_DWORD

   199  */

   200     case function_real_to_dword :

   201     {

   202         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   203 

   204         {

   205             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   207             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   208             symbol_c *IN_type_symbol = NULL;

   209             

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

   211             if (IN_param_value == NULL)

   212               IN_param_value = function_call_param_iterator.next_nf();

   213             if (IN_param_value != NULL) {

   214               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   215               last_type_symbol = last_type_symbol && IN_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 ;

   216             }

   217             

   218             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   219             {

   220         

   221                 function_name = (symbol_c*)(new pragma_c("__real_to_bit"));

   222                 

   223                 if (IN_type_symbol == NULL)

   224                   IN_type_symbol = last_type_symbol;

   225                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   226                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   227                 function_type_prefix = return_type_symbol;

   228                 break;

   229                 

   230             }

   231             

   232             

   233             ERROR;

   234         }

   235         

   236     }/*function_real_to_dword*/

   237     break;

   238 

   239 /****

   240  *REAL_TO_DT

   241  */

   242     case function_real_to_dt :

   243     {

   244         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   245 

   246         {

   247             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   249             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   250             symbol_c *IN_type_symbol = NULL;

   251             

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

   253             if (IN_param_value == NULL)

   254               IN_param_value = function_call_param_iterator.next_nf();

   255             if (IN_param_value != NULL) {

   256               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   257               last_type_symbol = last_type_symbol && IN_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 ;

   258             }

   259             

   260             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   261             {

   262         

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

   264                 

   265                 if (IN_type_symbol == NULL)

   266                   IN_type_symbol = last_type_symbol;

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

   268                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   269                 function_type_prefix = return_type_symbol;

   270                 break;

   271                 

   272             }

   273             

   274             

   275             ERROR;

   276         }

   277         

   278     }/*function_real_to_dt*/

   279     break;

   280 

   281 /****

   282  *REAL_TO_TOD

   283  */

   284     case function_real_to_tod :

   285     {

   286         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   287 

   288         {

   289             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("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_f(IN_param_name);

   292             symbol_c *IN_type_symbol = NULL;

   293             

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

   295             if (IN_param_value == NULL)

   296               IN_param_value = function_call_param_iterator.next_nf();

   297             if (IN_param_value != NULL) {

   298               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   299               last_type_symbol = last_type_symbol && IN_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 ;

   300             }

   301             

   302             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   303             {

   304         

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

   306                 

   307                 if (IN_type_symbol == NULL)

   308                   IN_type_symbol = last_type_symbol;

   309                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   310                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   311                 function_type_prefix = return_type_symbol;

   312                 break;

   313                 

   314             }

   315             

   316             

   317             ERROR;

   318         }

   319         

   320     }/*function_real_to_tod*/

   321     break;

   322 

   323 /****

   324  *REAL_TO_UDINT

   325  */

   326     case function_real_to_udint :

   327     {

   328         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   329 

   330         {

   331             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   333             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   334             symbol_c *IN_type_symbol = NULL;

   335             

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

   337             if (IN_param_value == NULL)

   338               IN_param_value = function_call_param_iterator.next_nf();

   339             if (IN_param_value != NULL) {

   340               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   341               last_type_symbol = last_type_symbol && IN_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 ;

   342             }

   343             

   344             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   345             {

   346         

   347                 function_name = (symbol_c*)(new pragma_c("__real_to_uint"));

   348                 

   349                 if (IN_type_symbol == NULL)

   350                   IN_type_symbol = last_type_symbol;

   351                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   352                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   353                 function_type_prefix = return_type_symbol;

   354                 break;

   355                 

   356             }

   357             

   358             

   359             ERROR;

   360         }

   361         

   362     }/*function_real_to_udint*/

   363     break;

   364 

   365 /****

   366  *REAL_TO_WORD

   367  */

   368     case function_real_to_word :

   369     {

   370         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   371 

   372         {

   373             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   375             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   376             symbol_c *IN_type_symbol = NULL;

   377             

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

   379             if (IN_param_value == NULL)

   380               IN_param_value = function_call_param_iterator.next_nf();

   381             if (IN_param_value != NULL) {

   382               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   384             }

   385             

   386             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   387             {

   388         

   389                 function_name = (symbol_c*)(new pragma_c("__real_to_bit"));

   390                 

   391                 if (IN_type_symbol == NULL)

   392                   IN_type_symbol = last_type_symbol;

   393                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   394                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   395                 function_type_prefix = return_type_symbol;

   396                 break;

   397                 

   398             }

   399             

   400             

   401             ERROR;

   402         }

   403         

   404     }/*function_real_to_word*/

   405     break;

   406 

   407 /****

   408  *REAL_TO_STRING

   409  */

   410     case function_real_to_string :

   411     {

   412         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   413 

   414         {

   415             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   417             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   418             symbol_c *IN_type_symbol = NULL;

   419             

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

   421             if (IN_param_value == NULL)

   422               IN_param_value = function_call_param_iterator.next_nf();

   423             if (IN_param_value != NULL) {

   424               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   425               last_type_symbol = last_type_symbol && IN_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 ;

   426             }

   427             

   428             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   429             {

   430         

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

   432                 

   433                 if (IN_type_symbol == NULL)

   434                   IN_type_symbol = last_type_symbol;

   435                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   436                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   437                 function_type_prefix = return_type_symbol;

   438                 break;

   439                 

   440             }

   441             

   442             

   443             ERROR;

   444         }

   445         

   446     }/*function_real_to_string*/

   447     break;

   448 

   449 /****

   450  *REAL_TO_LWORD

   451  */

   452     case function_real_to_lword :

   453     {

   454         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   455 

   456         {

   457             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   459             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   460             symbol_c *IN_type_symbol = NULL;

   461             

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

   463             if (IN_param_value == NULL)

   464               IN_param_value = function_call_param_iterator.next_nf();

   465             if (IN_param_value != NULL) {

   466               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   467               last_type_symbol = last_type_symbol && IN_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 ;

   468             }

   469             

   470             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   471             {

   472         

   473                 function_name = (symbol_c*)(new pragma_c("__real_to_bit"));

   474                 

   475                 if (IN_type_symbol == NULL)

   476                   IN_type_symbol = last_type_symbol;

   477                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   478                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   479                 function_type_prefix = return_type_symbol;

   480                 break;

   481                 

   482             }

   483             

   484             

   485             ERROR;

   486         }

   487         

   488     }/*function_real_to_lword*/

   489     break;

   490 

   491 /****

   492  *REAL_TO_UINT

   493  */

   494     case function_real_to_uint :

   495     {

   496         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   497 

   498         {

   499             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   501             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   502             symbol_c *IN_type_symbol = NULL;

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

   507             if (IN_param_value != NULL) {

   508               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   509               last_type_symbol = last_type_symbol && IN_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 ;

   510             }

   511             

   512             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   513             {

   514         

   515                 function_name = (symbol_c*)(new pragma_c("__real_to_uint"));

   516                 

   517                 if (IN_type_symbol == NULL)

   518                   IN_type_symbol = last_type_symbol;

   519                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   520                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   521                 function_type_prefix = return_type_symbol;

   522                 break;

   523                 

   524             }

   525             

   526             

   527             ERROR;

   528         }

   529         

   530     }/*function_real_to_uint*/

   531     break;

   532 

   533 /****

   534  *REAL_TO_LREAL

   535  */

   536     case function_real_to_lreal :

   537     {

   538         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   539 

   540         {

   541             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   543             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   544             symbol_c *IN_type_symbol = NULL;

   545             

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

   547             if (IN_param_value == NULL)

   548               IN_param_value = function_call_param_iterator.next_nf();

   549             if (IN_param_value != NULL) {

   550               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   551               last_type_symbol = last_type_symbol && IN_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 ;

   552             }

   553             

   554             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   555             {

   556         

   557                 function_name = (symbol_c*)(new pragma_c("__move_"));

   558                 

   559                 if (IN_type_symbol == NULL)

   560                   IN_type_symbol = last_type_symbol;

   561                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   562                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   563                 function_type_prefix = return_type_symbol;

   564                 function_type_suffix = IN_type_symbol;

   565                 break;

   566                 

   567             }

   568             

   569             

   570             ERROR;

   571         }

   572         

   573     }/*function_real_to_lreal*/

   574     break;

   575 

   576 /****

   577  *REAL_TO_BYTE

   578  */

   579     case function_real_to_byte :

   580     {

   581         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   582 

   583         {

   584             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   586             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   587             symbol_c *IN_type_symbol = NULL;

   588             

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

   590             if (IN_param_value == NULL)

   591               IN_param_value = function_call_param_iterator.next_nf();

   592             if (IN_param_value != NULL) {

   593               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   594               last_type_symbol = last_type_symbol && IN_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 ;

   595             }

   596             

   597             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   598             {

   599         

   600                 function_name = (symbol_c*)(new pragma_c("__real_to_bit"));

   601                 

   602                 if (IN_type_symbol == NULL)

   603                   IN_type_symbol = last_type_symbol;

   604                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   605                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   606                 function_type_prefix = return_type_symbol;

   607                 break;

   608                 

   609             }

   610             

   611             

   612             ERROR;

   613         }

   614         

   615     }/*function_real_to_byte*/

   616     break;

   617 

   618 /****

   619  *REAL_TO_USINT

   620  */

   621     case function_real_to_usint :

   622     {

   623         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   624 

   625         {

   626             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   628             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   629             symbol_c *IN_type_symbol = NULL;

   630             

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

   632             if (IN_param_value == NULL)

   633               IN_param_value = function_call_param_iterator.next_nf();

   634             if (IN_param_value != NULL) {

   635               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   636               last_type_symbol = last_type_symbol && IN_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 ;

   637             }

   638             

   639             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   640             {

   641         

   642                 function_name = (symbol_c*)(new pragma_c("__real_to_uint"));

   643                 

   644                 if (IN_type_symbol == NULL)

   645                   IN_type_symbol = last_type_symbol;

   646                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   647                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   648                 function_type_prefix = return_type_symbol;

   649                 break;

   650                 

   651             }

   652             

   653             

   654             ERROR;

   655         }

   656         

   657     }/*function_real_to_usint*/

   658     break;

   659 

   660 /****

   661  *REAL_TO_ULINT

   662  */

   663     case function_real_to_ulint :

   664     {

   665         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   666 

   667         {

   668             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   670             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   671             symbol_c *IN_type_symbol = NULL;

   672             

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

   674             if (IN_param_value == NULL)

   675               IN_param_value = function_call_param_iterator.next_nf();

   676             if (IN_param_value != NULL) {

   677               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   678               last_type_symbol = last_type_symbol && IN_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 ;

   679             }

   680             

   681             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   682             {

   683         

   684                 function_name = (symbol_c*)(new pragma_c("__real_to_uint"));

   685                 

   686                 if (IN_type_symbol == NULL)

   687                   IN_type_symbol = last_type_symbol;

   688                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   689                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   690                 function_type_prefix = return_type_symbol;

   691                 break;

   692                 

   693             }

   694             

   695             

   696             ERROR;

   697         }

   698         

   699     }/*function_real_to_ulint*/

   700     break;

   701 

   702 /****

   703  *REAL_TO_BOOL

   704  */

   705     case function_real_to_bool :

   706     {

   707         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   708 

   709         {

   710             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   712             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   713             symbol_c *IN_type_symbol = NULL;

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

   718             if (IN_param_value != NULL) {

   719               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   720               last_type_symbol = last_type_symbol && IN_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 ;

   721             }

   722             

   723             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   724             {

   725         

   726                 function_name = (symbol_c*)(new pragma_c("__real_to_bit"));

   727                 

   728                 if (IN_type_symbol == NULL)

   729                   IN_type_symbol = last_type_symbol;

   730                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   731                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   732                 function_type_prefix = return_type_symbol;

   733                 break;

   734                 

   735             }

   736             

   737             

   738             ERROR;

   739         }

   740         

   741     }/*function_real_to_bool*/

   742     break;

   743 

   744 /****

   745  *REAL_TO_TIME

   746  */

   747     case function_real_to_time :

   748     {

   749         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   750 

   751         {

   752             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   754             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   755             symbol_c *IN_type_symbol = NULL;

   756             

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

   758             if (IN_param_value == NULL)

   759               IN_param_value = function_call_param_iterator.next_nf();

   760             if (IN_param_value != NULL) {

   761               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   762               last_type_symbol = last_type_symbol && IN_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 ;

   763             }

   764             

   765             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   766             {

   767         

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

   769                 

   770                 if (IN_type_symbol == NULL)

   771                   IN_type_symbol = last_type_symbol;

   772                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   773                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   774                 function_type_prefix = return_type_symbol;

   775                 break;

   776                 

   777             }

   778             

   779             

   780             ERROR;

   781         }

   782         

   783     }/*function_real_to_time*/

   784     break;

   785 

   786 /****

   787  *REAL_TO_INT

   788  */

   789     case function_real_to_int :

   790     {

   791         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   792 

   793         {

   794             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   796             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   797             symbol_c *IN_type_symbol = NULL;

   798             

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

   800             if (IN_param_value == NULL)

   801               IN_param_value = function_call_param_iterator.next_nf();

   802             if (IN_param_value != NULL) {

   803               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   804               last_type_symbol = last_type_symbol && IN_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 ;

   805             }

   806             

   807             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   808             {

   809         

   810                 function_name = (symbol_c*)(new pragma_c("__real_to_sint"));

   811                 

   812                 if (IN_type_symbol == NULL)

   813                   IN_type_symbol = last_type_symbol;

   814                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   815                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   816                 function_type_prefix = return_type_symbol;

   817                 break;

   818                 

   819             }

   820             

   821             

   822             ERROR;

   823         }

   824         

   825     }/*function_real_to_int*/

   826     break;

   827 

   828 /****

   829  *SINT_TO_REAL

   830  */

   831     case function_sint_to_real :

   832     {

   833         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   834 

   835         {

   836             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   838             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   839             symbol_c *IN_type_symbol = NULL;

   840             

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

   842             if (IN_param_value == NULL)

   843               IN_param_value = function_call_param_iterator.next_nf();

   844             if (IN_param_value != NULL) {

   845               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   846               last_type_symbol = last_type_symbol && IN_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 ;

   847             }

   848             

   849             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   850             {

   851         

   852                 function_name = (symbol_c*)(new pragma_c("__move_"));

   853                 

   854                 if (IN_type_symbol == NULL)

   855                   IN_type_symbol = last_type_symbol;

   856                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   857                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   858                 function_type_prefix = return_type_symbol;

   859                 function_type_suffix = IN_type_symbol;

   860                 break;

   861                 

   862             }

   863             

   864             

   865             ERROR;

   866         }

   867         

   868     }/*function_sint_to_real*/

   869     break;

   870 

   871 /****

   872  *SINT_TO_LINT

   873  */

   874     case function_sint_to_lint :

   875     {

   876         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   877 

   878         {

   879             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   881             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   882             symbol_c *IN_type_symbol = NULL;

   883             

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

   885             if (IN_param_value == NULL)

   886               IN_param_value = function_call_param_iterator.next_nf();

   887             if (IN_param_value != NULL) {

   888               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   889               last_type_symbol = last_type_symbol && IN_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 ;

   890             }

   891             

   892             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   893             {

   894         

   895                 function_name = (symbol_c*)(new pragma_c("__move_"));

   896                 

   897                 if (IN_type_symbol == NULL)

   898                   IN_type_symbol = last_type_symbol;

   899                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   900                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   901                 function_type_prefix = return_type_symbol;

   902                 function_type_suffix = IN_type_symbol;

   903                 break;

   904                 

   905             }

   906             

   907             

   908             ERROR;

   909         }

   910         

   911     }/*function_sint_to_lint*/

   912     break;

   913 

   914 /****

   915  *SINT_TO_DINT

   916  */

   917     case function_sint_to_dint :

   918     {

   919         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   920 

   921         {

   922             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   924             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   925             symbol_c *IN_type_symbol = NULL;

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

   930             if (IN_param_value != NULL) {

   931               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   932               last_type_symbol = last_type_symbol && IN_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             }

   934             

   935             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   936             {

   937         

   938                 function_name = (symbol_c*)(new pragma_c("__move_"));

   939                 

   940                 if (IN_type_symbol == NULL)

   941                   IN_type_symbol = last_type_symbol;

   942                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   943                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   944                 function_type_prefix = return_type_symbol;

   945                 function_type_suffix = IN_type_symbol;

   946                 break;

   947                 

   948             }

   949             

   950             

   951             ERROR;

   952         }

   953         

   954     }/*function_sint_to_dint*/

   955     break;

   956 

   957 /****

   958  *SINT_TO_DATE

   959  */

   960     case function_sint_to_date :

   961     {

   962         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   963 

   964         {

   965             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

   967             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

   968             symbol_c *IN_type_symbol = NULL;

   969             

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

   971             if (IN_param_value == NULL)

   972               IN_param_value = function_call_param_iterator.next_nf();

   973             if (IN_param_value != NULL) {

   974               IN_type_symbol = search_expression_type->get_type(IN_param_value);

   975               last_type_symbol = last_type_symbol && IN_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 ;

   976             }

   977             

   978             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

   979             {

   980         

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

   982                 

   983                 if (IN_type_symbol == NULL)

   984                   IN_type_symbol = last_type_symbol;

   985                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   986                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   987                 function_type_prefix = return_type_symbol;

   988                 break;

   989                 

   990             }

   991             

   992             

   993             ERROR;

   994         }

   995         

   996     }/*function_sint_to_date*/

   997     break;

   998 

   999 /****

  1000  *SINT_TO_DWORD

  1001  */

  1002     case function_sint_to_dword :

  1003     {

  1004         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1005 

  1006         {

  1007             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

  1009             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

  1010             symbol_c *IN_type_symbol = NULL;

  1011             

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

  1013             if (IN_param_value == NULL)

  1014               IN_param_value = function_call_param_iterator.next_nf();

  1015             if (IN_param_value != NULL) {

  1016               IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1017               last_type_symbol = last_type_symbol && IN_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 ;

  1018             }

  1019             

  1020             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

  1021             {

  1022         

  1023                 function_name = (symbol_c*)(new pragma_c("__move_"));

  1024                 

  1025                 if (IN_type_symbol == NULL)

  1026                   IN_type_symbol = last_type_symbol;

  1027                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

  1028                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

  1029                 function_type_prefix = return_type_symbol;

  1030                 function_type_suffix = IN_type_symbol;

  1031                 break;

  1032                 

  1033             }

  1034             

  1035             

  1036             ERROR;

  1037         }

  1038         

  1039     }/*function_sint_to_dword*/

  1040     break;

  1041 

  1042 /****

  1043  *SINT_TO_DT

  1044  */

  1045     case function_sint_to_dt :

  1046     {

  1047         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1048 

  1049         {

  1050             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

  1052             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

  1053             symbol_c *IN_type_symbol = NULL;

  1054             

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

  1056             if (IN_param_value == NULL)

  1057               IN_param_value = function_call_param_iterator.next_nf();

  1058             if (IN_param_value != NULL) {

  1059               IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1060               last_type_symbol = last_type_symbol && IN_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 ;

  1061             }

  1062             

  1063             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

  1064             {

  1065         

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

  1067                 

  1068                 if (IN_type_symbol == NULL)

  1069                   IN_type_symbol = last_type_symbol;

  1070                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

  1071                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

  1072                 function_type_prefix = return_type_symbol;

  1073                 break;

  1074                 

  1075             }

  1076             

  1077             

  1078             ERROR;

  1079         }

  1080         

  1081     }/*function_sint_to_dt*/

  1082     break;

  1083 

  1084 /****

  1085  *SINT_TO_TOD

  1086  */

  1087     case function_sint_to_tod :

  1088     {

  1089         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1090 

  1091         {

  1092             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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

  1094             symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);

  1095             symbol_c *IN_type_symbol = NULL;

  1096             

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

  1098             if (IN_param_value == NULL)

  1099               IN_param_value = function_call_param_iterator.next_nf();

  1100             if (IN_param_value != NULL) {

  1101               IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1102               last_type_symbol = last_type_symbol && IN_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 ;

  1103             }

  1104             

  1105             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))

  1106             {

  1107         

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

  1109                 

  1110                 if (IN_type_symbol == NULL)

  1111                   IN_type_symbol = last_type_symbol;

  1112                 ADD_PARAM_LIST(IN_param_name, IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

  1113                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

  1114                 function_type_prefix = return_type_symbol;

  1115                 break;

  1116                 

  1117             }

  1118             

  1119             

  1120             ERROR;

  1121         }

  1122         

  1123     }/*function_sint_to_tod*/

  1124     break;

  1125 

  1126 /****

  1127  *SINT_TO_UDINT

  1128  */

  1129     case function_sint_to_udint :

  1130     {

  1131         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1132 

  1133         {

  1134             symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));

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