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 = &this->default_variable_name;

    40         

    41             symbol_c *IN_type_symbol = param_data_type;

    42             last_type_symbol = IN_type_symbol;

    43             

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

    45             {

    46         

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

    48                 

    49                 if (IN_type_symbol == NULL)

    50                   IN_type_symbol = last_type_symbol;

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

    52                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    53                 function_type_prefix = return_type_symbol;

    54                 break;

    55                 

    56             }

    57             

    58             

    59             ERROR;

    60         }

    61         

    62     }/*function_real_to_sint*/

    63     break;

    64 

    65 /****

    66  *REAL_TO_LINT

    67  */

    68     case function_real_to_lint :

    69     {

    70         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

    71 

    72         {

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

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

    75             symbol_c *IN_param_value = &this->default_variable_name;

    76         

    77             symbol_c *IN_type_symbol = param_data_type;

    78             last_type_symbol = IN_type_symbol;

    79             

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

    81             {

    82         

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

    84                 

    85                 if (IN_type_symbol == NULL)

    86                   IN_type_symbol = last_type_symbol;

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

    88                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

    89                 function_type_prefix = return_type_symbol;

    90                 break;

    91                 

    92             }

    93             

    94             

    95             ERROR;

    96         }

    97         

    98     }/*function_real_to_lint*/

    99     break;

   100 

   101 /****

   102  *REAL_TO_DINT

   103  */

   104     case function_real_to_dint :

   105     {

   106         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   107 

   108         {

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

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

   111             symbol_c *IN_param_value = &this->default_variable_name;

   112         

   113             symbol_c *IN_type_symbol = param_data_type;

   114             last_type_symbol = IN_type_symbol;

   115             

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

   117             {

   118         

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

   120                 

   121                 if (IN_type_symbol == NULL)

   122                   IN_type_symbol = last_type_symbol;

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

   124                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   125                 function_type_prefix = return_type_symbol;

   126                 break;

   127                 

   128             }

   129             

   130             

   131             ERROR;

   132         }

   133         

   134     }/*function_real_to_dint*/

   135     break;

   136 

   137 /****

   138  *REAL_TO_DATE

   139  */

   140     case function_real_to_date :

   141     {

   142         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   143 

   144         {

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

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

   147             symbol_c *IN_param_value = &this->default_variable_name;

   148         

   149             symbol_c *IN_type_symbol = param_data_type;

   150             last_type_symbol = IN_type_symbol;

   151             

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

   153             {

   154         

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

   156                 

   157                 if (IN_type_symbol == NULL)

   158                   IN_type_symbol = last_type_symbol;

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

   160                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   161                 function_type_prefix = return_type_symbol;

   162                 break;

   163                 

   164             }

   165             

   166             

   167             ERROR;

   168         }

   169         

   170     }/*function_real_to_date*/

   171     break;

   172 

   173 /****

   174  *REAL_TO_DWORD

   175  */

   176     case function_real_to_dword :

   177     {

   178         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   179 

   180         {

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

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

   183             symbol_c *IN_param_value = &this->default_variable_name;

   184         

   185             symbol_c *IN_type_symbol = param_data_type;

   186             last_type_symbol = IN_type_symbol;

   187             

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

   189             {

   190         

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

   192                 

   193                 if (IN_type_symbol == NULL)

   194                   IN_type_symbol = last_type_symbol;

   195                 ADD_PARAM_LIST(IN_param_name, 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 = &search_constant_type_c::real_type_name;

   215 

   216         {

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

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

   219             symbol_c *IN_param_value = &this->default_variable_name;

   220         

   221             symbol_c *IN_type_symbol = param_data_type;

   222             last_type_symbol = IN_type_symbol;

   223             

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

   225             {

   226         

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

   228                 

   229                 if (IN_type_symbol == NULL)

   230                   IN_type_symbol = last_type_symbol;

   231                 ADD_PARAM_LIST(IN_param_name, 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 = &search_constant_type_c::real_type_name;

   251 

   252         {

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

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

   255             symbol_c *IN_param_value = &this->default_variable_name;

   256         

   257             symbol_c *IN_type_symbol = param_data_type;

   258             last_type_symbol = IN_type_symbol;

   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::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 = &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 = &this->default_variable_name;

   292         

   293             symbol_c *IN_type_symbol = param_data_type;

   294             last_type_symbol = IN_type_symbol;

   295             

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

   297             {

   298         

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

   300                 

   301                 if (IN_type_symbol == NULL)

   302                   IN_type_symbol = last_type_symbol;

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

   304                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   305                 function_type_prefix = return_type_symbol;

   306                 break;

   307                 

   308             }

   309             

   310             

   311             ERROR;

   312         }

   313         

   314     }/*function_real_to_udint*/

   315     break;

   316 

   317 /****

   318  *REAL_TO_WORD

   319  */

   320     case function_real_to_word :

   321     {

   322         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   323 

   324         {

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

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

   327             symbol_c *IN_param_value = &this->default_variable_name;

   328         

   329             symbol_c *IN_type_symbol = param_data_type;

   330             last_type_symbol = IN_type_symbol;

   331             

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

   333             {

   334         

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

   336                 

   337                 if (IN_type_symbol == NULL)

   338                   IN_type_symbol = last_type_symbol;

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

   340                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   341                 function_type_prefix = return_type_symbol;

   342                 break;

   343                 

   344             }

   345             

   346             

   347             ERROR;

   348         }

   349         

   350     }/*function_real_to_word*/

   351     break;

   352 

   353 /****

   354  *REAL_TO_STRING

   355  */

   356     case function_real_to_string :

   357     {

   358         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   359 

   360         {

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

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

   363             symbol_c *IN_param_value = &this->default_variable_name;

   364         

   365             symbol_c *IN_type_symbol = param_data_type;

   366             last_type_symbol = IN_type_symbol;

   367             

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

   369             {

   370         

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

   372                 

   373                 if (IN_type_symbol == NULL)

   374                   IN_type_symbol = last_type_symbol;

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

   376                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   377                 function_type_prefix = return_type_symbol;

   378                 break;

   379                 

   380             }

   381             

   382             

   383             ERROR;

   384         }

   385         

   386     }/*function_real_to_string*/

   387     break;

   388 

   389 /****

   390  *REAL_TO_LWORD

   391  */

   392     case function_real_to_lword :

   393     {

   394         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   395 

   396         {

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

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

   399             symbol_c *IN_param_value = &this->default_variable_name;

   400         

   401             symbol_c *IN_type_symbol = param_data_type;

   402             last_type_symbol = IN_type_symbol;

   403             

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

   405             {

   406         

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

   408                 

   409                 if (IN_type_symbol == NULL)

   410                   IN_type_symbol = last_type_symbol;

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

   412                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   413                 function_type_prefix = return_type_symbol;

   414                 break;

   415                 

   416             }

   417             

   418             

   419             ERROR;

   420         }

   421         

   422     }/*function_real_to_lword*/

   423     break;

   424 

   425 /****

   426  *REAL_TO_UINT

   427  */

   428     case function_real_to_uint :

   429     {

   430         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   431 

   432         {

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

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

   435             symbol_c *IN_param_value = &this->default_variable_name;

   436         

   437             symbol_c *IN_type_symbol = param_data_type;

   438             last_type_symbol = IN_type_symbol;

   439             

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

   441             {

   442         

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

   444                 

   445                 if (IN_type_symbol == NULL)

   446                   IN_type_symbol = last_type_symbol;

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

   448                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   449                 function_type_prefix = return_type_symbol;

   450                 break;

   451                 

   452             }

   453             

   454             

   455             ERROR;

   456         }

   457         

   458     }/*function_real_to_uint*/

   459     break;

   460 

   461 /****

   462  *REAL_TO_LREAL

   463  */

   464     case function_real_to_lreal :

   465     {

   466         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   467 

   468         {

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

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

   471             symbol_c *IN_param_value = &this->default_variable_name;

   472         

   473             symbol_c *IN_type_symbol = param_data_type;

   474             last_type_symbol = IN_type_symbol;

   475             

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

   477             {

   478         

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

   480                 

   481                 if (IN_type_symbol == NULL)

   482                   IN_type_symbol = last_type_symbol;

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

   484                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   485                 function_type_prefix = return_type_symbol;

   486                 function_type_suffix = IN_type_symbol;

   487                 break;

   488                 

   489             }

   490             

   491             

   492             ERROR;

   493         }

   494         

   495     }/*function_real_to_lreal*/

   496     break;

   497 

   498 /****

   499  *REAL_TO_BYTE

   500  */

   501     case function_real_to_byte :

   502     {

   503         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   504 

   505         {

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

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

   508             symbol_c *IN_param_value = &this->default_variable_name;

   509         

   510             symbol_c *IN_type_symbol = param_data_type;

   511             last_type_symbol = IN_type_symbol;

   512             

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

   514             {

   515         

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

   517                 

   518                 if (IN_type_symbol == NULL)

   519                   IN_type_symbol = last_type_symbol;

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

   521                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   522                 function_type_prefix = return_type_symbol;

   523                 break;

   524                 

   525             }

   526             

   527             

   528             ERROR;

   529         }

   530         

   531     }/*function_real_to_byte*/

   532     break;

   533 

   534 /****

   535  *REAL_TO_USINT

   536  */

   537     case function_real_to_usint :

   538     {

   539         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   540 

   541         {

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

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

   544             symbol_c *IN_param_value = &this->default_variable_name;

   545         

   546             symbol_c *IN_type_symbol = param_data_type;

   547             last_type_symbol = IN_type_symbol;

   548             

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

   550             {

   551         

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

   553                 

   554                 if (IN_type_symbol == NULL)

   555                   IN_type_symbol = last_type_symbol;

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

   557                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   558                 function_type_prefix = return_type_symbol;

   559                 break;

   560                 

   561             }

   562             

   563             

   564             ERROR;

   565         }

   566         

   567     }/*function_real_to_usint*/

   568     break;

   569 

   570 /****

   571  *REAL_TO_ULINT

   572  */

   573     case function_real_to_ulint :

   574     {

   575         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   576 

   577         {

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

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

   580             symbol_c *IN_param_value = &this->default_variable_name;

   581         

   582             symbol_c *IN_type_symbol = param_data_type;

   583             last_type_symbol = IN_type_symbol;

   584             

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

   586             {

   587         

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

   589                 

   590                 if (IN_type_symbol == NULL)

   591                   IN_type_symbol = last_type_symbol;

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

   593                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   594                 function_type_prefix = return_type_symbol;

   595                 break;

   596                 

   597             }

   598             

   599             

   600             ERROR;

   601         }

   602         

   603     }/*function_real_to_ulint*/

   604     break;

   605 

   606 /****

   607  *REAL_TO_BOOL

   608  */

   609     case function_real_to_bool :

   610     {

   611         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   612 

   613         {

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

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

   616             symbol_c *IN_param_value = &this->default_variable_name;

   617         

   618             symbol_c *IN_type_symbol = param_data_type;

   619             last_type_symbol = IN_type_symbol;

   620             

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

   622             {

   623         

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

   625                 

   626                 if (IN_type_symbol == NULL)

   627                   IN_type_symbol = last_type_symbol;

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

   629                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   630                 function_type_prefix = return_type_symbol;

   631                 break;

   632                 

   633             }

   634             

   635             

   636             ERROR;

   637         }

   638         

   639     }/*function_real_to_bool*/

   640     break;

   641 

   642 /****

   643  *REAL_TO_TIME

   644  */

   645     case function_real_to_time :

   646     {

   647         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   648 

   649         {

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

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

   652             symbol_c *IN_param_value = &this->default_variable_name;

   653         

   654             symbol_c *IN_type_symbol = param_data_type;

   655             last_type_symbol = IN_type_symbol;

   656             

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

   658             {

   659         

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

   661                 

   662                 if (IN_type_symbol == NULL)

   663                   IN_type_symbol = last_type_symbol;

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

   665                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   666                 function_type_prefix = return_type_symbol;

   667                 break;

   668                 

   669             }

   670             

   671             

   672             ERROR;

   673         }

   674         

   675     }/*function_real_to_time*/

   676     break;

   677 

   678 /****

   679  *REAL_TO_INT

   680  */

   681     case function_real_to_int :

   682     {

   683         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   684 

   685         {

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

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

   688             symbol_c *IN_param_value = &this->default_variable_name;

   689         

   690             symbol_c *IN_type_symbol = param_data_type;

   691             last_type_symbol = IN_type_symbol;

   692             

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

   694             {

   695         

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

   697                 

   698                 if (IN_type_symbol == NULL)

   699                   IN_type_symbol = last_type_symbol;

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

   701                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   702                 function_type_prefix = return_type_symbol;

   703                 break;

   704                 

   705             }

   706             

   707             

   708             ERROR;

   709         }

   710         

   711     }/*function_real_to_int*/

   712     break;

   713 

   714 /****

   715  *SINT_TO_REAL

   716  */

   717     case function_sint_to_real :

   718     {

   719         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   720 

   721         {

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

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

   724             symbol_c *IN_param_value = &this->default_variable_name;

   725         

   726             symbol_c *IN_type_symbol = param_data_type;

   727             last_type_symbol = IN_type_symbol;

   728             

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

   730             {

   731         

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

   733                 

   734                 if (IN_type_symbol == NULL)

   735                   IN_type_symbol = last_type_symbol;

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

   737                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   738                 function_type_prefix = return_type_symbol;

   739                 function_type_suffix = IN_type_symbol;

   740                 break;

   741                 

   742             }

   743             

   744             

   745             ERROR;

   746         }

   747         

   748     }/*function_sint_to_real*/

   749     break;

   750 

   751 /****

   752  *SINT_TO_LINT

   753  */

   754     case function_sint_to_lint :

   755     {

   756         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   757 

   758         {

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

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

   761             symbol_c *IN_param_value = &this->default_variable_name;

   762         

   763             symbol_c *IN_type_symbol = param_data_type;

   764             last_type_symbol = IN_type_symbol;

   765             

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

   767             {

   768         

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

   770                 

   771                 if (IN_type_symbol == NULL)

   772                   IN_type_symbol = last_type_symbol;

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

   774                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   775                 function_type_prefix = return_type_symbol;

   776                 function_type_suffix = IN_type_symbol;

   777                 break;

   778                 

   779             }

   780             

   781             

   782             ERROR;

   783         }

   784         

   785     }/*function_sint_to_lint*/

   786     break;

   787 

   788 /****

   789  *SINT_TO_DINT

   790  */

   791     case function_sint_to_dint :

   792     {

   793         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   794 

   795         {

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

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

   798             symbol_c *IN_param_value = &this->default_variable_name;

   799         

   800             symbol_c *IN_type_symbol = param_data_type;

   801             last_type_symbol = IN_type_symbol;

   802             

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

   804             {

   805         

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

   807                 

   808                 if (IN_type_symbol == NULL)

   809                   IN_type_symbol = last_type_symbol;

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

   811                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   812                 function_type_prefix = return_type_symbol;

   813                 function_type_suffix = IN_type_symbol;

   814                 break;

   815                 

   816             }

   817             

   818             

   819             ERROR;

   820         }

   821         

   822     }/*function_sint_to_dint*/

   823     break;

   824 

   825 /****

   826  *SINT_TO_DATE

   827  */

   828     case function_sint_to_date :

   829     {

   830         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   831 

   832         {

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

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

   835             symbol_c *IN_param_value = &this->default_variable_name;

   836         

   837             symbol_c *IN_type_symbol = param_data_type;

   838             last_type_symbol = IN_type_symbol;

   839             

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

   841             {

   842         

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

   844                 

   845                 if (IN_type_symbol == NULL)

   846                   IN_type_symbol = last_type_symbol;

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

   848                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   849                 function_type_prefix = return_type_symbol;

   850                 break;

   851                 

   852             }

   853             

   854             

   855             ERROR;

   856         }

   857         

   858     }/*function_sint_to_date*/

   859     break;

   860 

   861 /****

   862  *SINT_TO_DWORD

   863  */

   864     case function_sint_to_dword :

   865     {

   866         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   867 

   868         {

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

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

   871             symbol_c *IN_param_value = &this->default_variable_name;

   872         

   873             symbol_c *IN_type_symbol = param_data_type;

   874             last_type_symbol = IN_type_symbol;

   875             

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

   877             {

   878         

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

   880                 

   881                 if (IN_type_symbol == NULL)

   882                   IN_type_symbol = last_type_symbol;

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

   884                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   885                 function_type_prefix = return_type_symbol;

   886                 function_type_suffix = IN_type_symbol;

   887                 break;

   888                 

   889             }

   890             

   891             

   892             ERROR;

   893         }

   894         

   895     }/*function_sint_to_dword*/

   896     break;

   897 

   898 /****

   899  *SINT_TO_DT

   900  */

   901     case function_sint_to_dt :

   902     {

   903         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   904 

   905         {

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

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

   908             symbol_c *IN_param_value = &this->default_variable_name;

   909         

   910             symbol_c *IN_type_symbol = param_data_type;

   911             last_type_symbol = IN_type_symbol;

   912             

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

   914             {

   915         

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

   917                 

   918                 if (IN_type_symbol == NULL)

   919                   IN_type_symbol = last_type_symbol;

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

   921                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   922                 function_type_prefix = return_type_symbol;

   923                 break;

   924                 

   925             }

   926             

   927             

   928             ERROR;

   929         }

   930         

   931     }/*function_sint_to_dt*/

   932     break;

   933 

   934 /****

   935  *SINT_TO_TOD

   936  */

   937     case function_sint_to_tod :

   938     {

   939         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   940 

   941         {

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

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

   944             symbol_c *IN_param_value = &this->default_variable_name;

   945         

   946             symbol_c *IN_type_symbol = param_data_type;

   947             last_type_symbol = IN_type_symbol;

   948             

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

   950             {

   951         

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

   953                 

   954                 if (IN_type_symbol == NULL)

   955                   IN_type_symbol = last_type_symbol;

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

   957                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   958                 function_type_prefix = return_type_symbol;

   959                 break;

   960                 

   961             }

   962             

   963             

   964             ERROR;

   965         }

   966         

   967     }/*function_sint_to_tod*/

   968     break;

   969 

   970 /****

   971  *SINT_TO_UDINT

   972  */

   973     case function_sint_to_udint :

   974     {

   975         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   976 

   977         {

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

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

   980             symbol_c *IN_param_value = &this->default_variable_name;

   981         

   982             symbol_c *IN_type_symbol = param_data_type;

   983             last_type_symbol = IN_type_symbol;

   984             

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

   986             {

   987         

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

   989                 

   990                 if (IN_type_symbol == NULL)

   991                   IN_type_symbol = last_type_symbol;

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

   993                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   994                 function_type_prefix = return_type_symbol;

   995                 function_type_suffix = IN_type_symbol;

   996                 break;

   997                 

   998             }

   999             

  1000             

  1001             ERROR;

  1002         }

  1003         

  1004     }/*function_sint_to_udint*/

  1005     break;

  1006 

  1007 /****

  1008  *SINT_TO_WORD

  1009  */

  1010     case function_sint_to_word :

  1011     {

  1012         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1013 

  1014         {

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

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

  1017             symbol_c *IN_param_value = &this->default_variable_name;

  1018         

  1019             symbol_c *IN_type_symbol = param_data_type;

  1020             last_type_symbol = IN_type_symbol;

  1021             

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

  1023             {

  1024         

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

  1026                 

  1027                 if (IN_type_symbol == NULL)

  1028                   IN_type_symbol = last_type_symbol;

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

  1030                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

  1031                 function_type_prefix = return_type_symbol;

  1032                 function_type_suffix = IN_type_symbol;

  1033                 break;

  1034                 

  1035             }

  1036             

  1037             

  1038             ERROR;

  1039         }

  1040         

  1041     }/*function_sint_to_word*/

  1042     break;

  1043 

  1044 /****

  1045  *SINT_TO_STRING

  1046  */

  1047     case function_sint_to_string :

  1048     {

  1049         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1050 

  1051         {

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

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

  1054             symbol_c *IN_param_value = &this->default_variable_name;

  1055         

  1056             symbol_c *IN_type_symbol = param_data_type;

  1057             last_type_symbol = IN_type_symbol;

  1058             

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

  1060             {

  1061         

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

  1063                 

  1064                 if (IN_type_symbol == NULL)

  1065                   IN_type_symbol = last_type_symbol;

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

  1067                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

  1068                 function_type_prefix = return_type_symbol;

  1069                 break;

  1070                 

  1071             }

  1072             

  1073             

  1074             ERROR;

  1075         }

  1076         

  1077     }/*function_sint_to_string*/

  1078     break;

  1079 

  1080 /****

  1081  *SINT_TO_LWORD

  1082  */

  1083     case function_sint_to_lword :

  1084     {

  1085         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1086 

  1087         {

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

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

  1090             symbol_c *IN_param_value = &this->default_variable_name;

  1091         

  1092             symbol_c *IN_type_symbol = param_data_type;

  1093             last_type_symbol = IN_type_symbol;

  1094             

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

  1096             {

  1097         

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

  1099                 

  1100                 if (IN_type_symbol == NULL)

  1101                   IN_type_symbol = last_type_symbol;

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

  1103                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

  1104                 function_type_prefix = return_type_symbol;

  1105                 function_type_suffix = IN_type_symbol;

  1106                 break;

  1107                 

  1108             }

  1109             

  1110             

  1111             ERROR;

  1112         }

  1113         

  1114     }/*function_sint_to_lword*/

  1115     break;

  1116 

  1117 /****

  1118  *SINT_TO_UINT

  1119  */

  1120     case function_sint_to_uint :

  1121     {

  1122         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1123 

  1124         {

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

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

  1127             symbol_c *IN_param_value = &this->default_variable_name;

  1128         

  1129             symbol_c *IN_type_symbol = param_data_type;

  1130             last_type_symbol = IN_type_symbol;

  1131             

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

  1133             {

  1134         

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