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 

    28 void *search_expression_type_c::compute_standard_function_default(function_invocation_c *st_symbol = NULL, il_formal_funct_call_c *il_symbol = NULL) {

    29   function_type_t current_function_type;

    30   function_call_param_iterator_c *tmp_function_call_param_iterator;

    31   if (st_symbol != NULL && il_symbol == NULL) {

    32     current_function_type = get_function_type((identifier_c *)st_symbol->function_name);

    33     tmp_function_call_param_iterator = new function_call_param_iterator_c(st_symbol);

    34   }

    35   else if (st_symbol == NULL && il_symbol != NULL) {

    36     current_function_type = get_function_type((identifier_c *)il_symbol->function_name);

    37     tmp_function_call_param_iterator = new function_call_param_iterator_c(il_symbol);

    38   }

    39   else

    40     ERROR;

    41   function_call_param_iterator_c function_call_param_iterator(*tmp_function_call_param_iterator);

    42   search_expression_type_c* search_expression_type = this;

    43 

    44   switch(current_function_type){

    45 

    46 /****

    47  *REAL_TO_SINT

    48  */

    49     case function_real_to_sint :

    50     {

    51         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

    52 

    53         {

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

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

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

    57             symbol_c *IN_type_symbol = NULL;

    58             

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

    60             if (IN_param_value == NULL)

    61               IN_param_value = function_call_param_iterator.next_nf();

    62             if (IN_param_value != NULL) {

    63               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

    65             }

    66             

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

    68             {

    69         

    70                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    71                 return return_type_symbol;

    72                 

    73             }

    74             

    75             

    76             ERROR;

    77         }

    78         

    79     }/*function_real_to_sint*/

    80     break;

    81 

    82 /****

    83  *REAL_TO_LINT

    84  */

    85     case function_real_to_lint :

    86     {

    87         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

    88 

    89         {

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

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

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

    93             symbol_c *IN_type_symbol = NULL;

    94             

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

    96             if (IN_param_value == NULL)

    97               IN_param_value = function_call_param_iterator.next_nf();

    98             if (IN_param_value != NULL) {

    99               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   101             }

   102             

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

   104             {

   105         

   106                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   107                 return return_type_symbol;

   108                 

   109             }

   110             

   111             

   112             ERROR;

   113         }

   114         

   115     }/*function_real_to_lint*/

   116     break;

   117 

   118 /****

   119  *REAL_TO_DINT

   120  */

   121     case function_real_to_dint :

   122     {

   123         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   124 

   125         {

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

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

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

   129             symbol_c *IN_type_symbol = NULL;

   130             

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

   132             if (IN_param_value == NULL)

   133               IN_param_value = function_call_param_iterator.next_nf();

   134             if (IN_param_value != NULL) {

   135               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   137             }

   138             

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

   140             {

   141         

   142                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   143                 return return_type_symbol;

   144                 

   145             }

   146             

   147             

   148             ERROR;

   149         }

   150         

   151     }/*function_real_to_dint*/

   152     break;

   153 

   154 /****

   155  *REAL_TO_DATE

   156  */

   157     case function_real_to_date :

   158     {

   159         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   160 

   161         {

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

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

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

   165             symbol_c *IN_type_symbol = NULL;

   166             

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

   168             if (IN_param_value == NULL)

   169               IN_param_value = function_call_param_iterator.next_nf();

   170             if (IN_param_value != NULL) {

   171               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   173             }

   174             

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

   176             {

   177         

   178                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   179                 return return_type_symbol;

   180                 

   181             }

   182             

   183             

   184             ERROR;

   185         }

   186         

   187     }/*function_real_to_date*/

   188     break;

   189 

   190 /****

   191  *REAL_TO_DWORD

   192  */

   193     case function_real_to_dword :

   194     {

   195         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   196 

   197         {

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

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

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

   201             symbol_c *IN_type_symbol = NULL;

   202             

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

   204             if (IN_param_value == NULL)

   205               IN_param_value = function_call_param_iterator.next_nf();

   206             if (IN_param_value != NULL) {

   207               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   209             }

   210             

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

   212             {

   213         

   214                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   215                 return return_type_symbol;

   216                 

   217             }

   218             

   219             

   220             ERROR;

   221         }

   222         

   223     }/*function_real_to_dword*/

   224     break;

   225 

   226 /****

   227  *REAL_TO_DT

   228  */

   229     case function_real_to_dt :

   230     {

   231         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   232 

   233         {

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

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

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

   237             symbol_c *IN_type_symbol = NULL;

   238             

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

   240             if (IN_param_value == NULL)

   241               IN_param_value = function_call_param_iterator.next_nf();

   242             if (IN_param_value != NULL) {

   243               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   245             }

   246             

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

   248             {

   249         

   250                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   251                 return return_type_symbol;

   252                 

   253             }

   254             

   255             

   256             ERROR;

   257         }

   258         

   259     }/*function_real_to_dt*/

   260     break;

   261 

   262 /****

   263  *REAL_TO_TOD

   264  */

   265     case function_real_to_tod :

   266     {

   267         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   268 

   269         {

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

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

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

   273             symbol_c *IN_type_symbol = NULL;

   274             

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

   276             if (IN_param_value == NULL)

   277               IN_param_value = function_call_param_iterator.next_nf();

   278             if (IN_param_value != NULL) {

   279               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   281             }

   282             

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

   284             {

   285         

   286                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   287                 return return_type_symbol;

   288                 

   289             }

   290             

   291             

   292             ERROR;

   293         }

   294         

   295     }/*function_real_to_tod*/

   296     break;

   297 

   298 /****

   299  *REAL_TO_UDINT

   300  */

   301     case function_real_to_udint :

   302     {

   303         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   304 

   305         {

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

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

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

   309             symbol_c *IN_type_symbol = NULL;

   310             

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

   312             if (IN_param_value == NULL)

   313               IN_param_value = function_call_param_iterator.next_nf();

   314             if (IN_param_value != NULL) {

   315               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   317             }

   318             

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

   320             {

   321         

   322                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   323                 return return_type_symbol;

   324                 

   325             }

   326             

   327             

   328             ERROR;

   329         }

   330         

   331     }/*function_real_to_udint*/

   332     break;

   333 

   334 /****

   335  *REAL_TO_WORD

   336  */

   337     case function_real_to_word :

   338     {

   339         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   340 

   341         {

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

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

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

   345             symbol_c *IN_type_symbol = NULL;

   346             

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

   348             if (IN_param_value == NULL)

   349               IN_param_value = function_call_param_iterator.next_nf();

   350             if (IN_param_value != NULL) {

   351               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   353             }

   354             

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

   356             {

   357         

   358                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   359                 return return_type_symbol;

   360                 

   361             }

   362             

   363             

   364             ERROR;

   365         }

   366         

   367     }/*function_real_to_word*/

   368     break;

   369 

   370 /****

   371  *REAL_TO_STRING

   372  */

   373     case function_real_to_string :

   374     {

   375         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   376 

   377         {

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

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

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

   381             symbol_c *IN_type_symbol = NULL;

   382             

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

   384             if (IN_param_value == NULL)

   385               IN_param_value = function_call_param_iterator.next_nf();

   386             if (IN_param_value != NULL) {

   387               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   389             }

   390             

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

   392             {

   393         

   394                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   395                 return return_type_symbol;

   396                 

   397             }

   398             

   399             

   400             ERROR;

   401         }

   402         

   403     }/*function_real_to_string*/

   404     break;

   405 

   406 /****

   407  *REAL_TO_LWORD

   408  */

   409     case function_real_to_lword :

   410     {

   411         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   412 

   413         {

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

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

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

   417             symbol_c *IN_type_symbol = NULL;

   418             

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

   420             if (IN_param_value == NULL)

   421               IN_param_value = function_call_param_iterator.next_nf();

   422             if (IN_param_value != NULL) {

   423               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   425             }

   426             

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

   428             {

   429         

   430                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   431                 return return_type_symbol;

   432                 

   433             }

   434             

   435             

   436             ERROR;

   437         }

   438         

   439     }/*function_real_to_lword*/

   440     break;

   441 

   442 /****

   443  *REAL_TO_UINT

   444  */

   445     case function_real_to_uint :

   446     {

   447         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   448 

   449         {

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

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

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

   453             symbol_c *IN_type_symbol = NULL;

   454             

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

   456             if (IN_param_value == NULL)

   457               IN_param_value = function_call_param_iterator.next_nf();

   458             if (IN_param_value != NULL) {

   459               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   461             }

   462             

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

   464             {

   465         

   466                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   467                 return return_type_symbol;

   468                 

   469             }

   470             

   471             

   472             ERROR;

   473         }

   474         

   475     }/*function_real_to_uint*/

   476     break;

   477 

   478 /****

   479  *REAL_TO_LREAL

   480  */

   481     case function_real_to_lreal :

   482     {

   483         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   484 

   485         {

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

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

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

   489             symbol_c *IN_type_symbol = NULL;

   490             

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

   492             if (IN_param_value == NULL)

   493               IN_param_value = function_call_param_iterator.next_nf();

   494             if (IN_param_value != NULL) {

   495               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   497             }

   498             

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

   500             {

   501         

   502                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   503                 return return_type_symbol;

   504                 

   505             }

   506             

   507             

   508             ERROR;

   509         }

   510         

   511     }/*function_real_to_lreal*/

   512     break;

   513 

   514 /****

   515  *REAL_TO_BYTE

   516  */

   517     case function_real_to_byte :

   518     {

   519         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   520 

   521         {

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

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

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

   525             symbol_c *IN_type_symbol = NULL;

   526             

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

   528             if (IN_param_value == NULL)

   529               IN_param_value = function_call_param_iterator.next_nf();

   530             if (IN_param_value != NULL) {

   531               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   533             }

   534             

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

   536             {

   537         

   538                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   539                 return return_type_symbol;

   540                 

   541             }

   542             

   543             

   544             ERROR;

   545         }

   546         

   547     }/*function_real_to_byte*/

   548     break;

   549 

   550 /****

   551  *REAL_TO_USINT

   552  */

   553     case function_real_to_usint :

   554     {

   555         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   556 

   557         {

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

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

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

   561             symbol_c *IN_type_symbol = NULL;

   562             

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

   564             if (IN_param_value == NULL)

   565               IN_param_value = function_call_param_iterator.next_nf();

   566             if (IN_param_value != NULL) {

   567               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   569             }

   570             

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

   572             {

   573         

   574                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   575                 return return_type_symbol;

   576                 

   577             }

   578             

   579             

   580             ERROR;

   581         }

   582         

   583     }/*function_real_to_usint*/

   584     break;

   585 

   586 /****

   587  *REAL_TO_ULINT

   588  */

   589     case function_real_to_ulint :

   590     {

   591         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   592 

   593         {

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

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

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

   597             symbol_c *IN_type_symbol = NULL;

   598             

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

   600             if (IN_param_value == NULL)

   601               IN_param_value = function_call_param_iterator.next_nf();

   602             if (IN_param_value != NULL) {

   603               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   605             }

   606             

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

   608             {

   609         

   610                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   611                 return return_type_symbol;

   612                 

   613             }

   614             

   615             

   616             ERROR;

   617         }

   618         

   619     }/*function_real_to_ulint*/

   620     break;

   621 

   622 /****

   623  *REAL_TO_BOOL

   624  */

   625     case function_real_to_bool :

   626     {

   627         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   628 

   629         {

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

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

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

   633             symbol_c *IN_type_symbol = NULL;

   634             

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

   636             if (IN_param_value == NULL)

   637               IN_param_value = function_call_param_iterator.next_nf();

   638             if (IN_param_value != NULL) {

   639               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   641             }

   642             

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

   644             {

   645         

   646                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   647                 return return_type_symbol;

   648                 

   649             }

   650             

   651             

   652             ERROR;

   653         }

   654         

   655     }/*function_real_to_bool*/

   656     break;

   657 

   658 /****

   659  *REAL_TO_TIME

   660  */

   661     case function_real_to_time :

   662     {

   663         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   664 

   665         {

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

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

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

   669             symbol_c *IN_type_symbol = NULL;

   670             

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

   672             if (IN_param_value == NULL)

   673               IN_param_value = function_call_param_iterator.next_nf();

   674             if (IN_param_value != NULL) {

   675               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   677             }

   678             

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

   680             {

   681         

   682                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   683                 return return_type_symbol;

   684                 

   685             }

   686             

   687             

   688             ERROR;

   689         }

   690         

   691     }/*function_real_to_time*/

   692     break;

   693 

   694 /****

   695  *REAL_TO_INT

   696  */

   697     case function_real_to_int :

   698     {

   699         symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;

   700 

   701         {

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

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

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

   705             symbol_c *IN_type_symbol = NULL;

   706             

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

   708             if (IN_param_value == NULL)

   709               IN_param_value = function_call_param_iterator.next_nf();

   710             if (IN_param_value != NULL) {

   711               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   713             }

   714             

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

   716             {

   717         

   718                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   719                 return return_type_symbol;

   720                 

   721             }

   722             

   723             

   724             ERROR;

   725         }

   726         

   727     }/*function_real_to_int*/

   728     break;

   729 

   730 /****

   731  *SINT_TO_REAL

   732  */

   733     case function_sint_to_real :

   734     {

   735         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   736 

   737         {

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

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

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

   741             symbol_c *IN_type_symbol = NULL;

   742             

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

   744             if (IN_param_value == NULL)

   745               IN_param_value = function_call_param_iterator.next_nf();

   746             if (IN_param_value != NULL) {

   747               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   749             }

   750             

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

   752             {

   753         

   754                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   755                 return return_type_symbol;

   756                 

   757             }

   758             

   759             

   760             ERROR;

   761         }

   762         

   763     }/*function_sint_to_real*/

   764     break;

   765 

   766 /****

   767  *SINT_TO_LINT

   768  */

   769     case function_sint_to_lint :

   770     {

   771         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   772 

   773         {

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

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

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

   777             symbol_c *IN_type_symbol = NULL;

   778             

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

   780             if (IN_param_value == NULL)

   781               IN_param_value = function_call_param_iterator.next_nf();

   782             if (IN_param_value != NULL) {

   783               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   785             }

   786             

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

   788             {

   789         

   790                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   791                 return return_type_symbol;

   792                 

   793             }

   794             

   795             

   796             ERROR;

   797         }

   798         

   799     }/*function_sint_to_lint*/

   800     break;

   801 

   802 /****

   803  *SINT_TO_DINT

   804  */

   805     case function_sint_to_dint :

   806     {

   807         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   808 

   809         {

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

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

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

   813             symbol_c *IN_type_symbol = NULL;

   814             

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

   816             if (IN_param_value == NULL)

   817               IN_param_value = function_call_param_iterator.next_nf();

   818             if (IN_param_value != NULL) {

   819               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   821             }

   822             

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

   824             {

   825         

   826                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   827                 return return_type_symbol;

   828                 

   829             }

   830             

   831             

   832             ERROR;

   833         }

   834         

   835     }/*function_sint_to_dint*/

   836     break;

   837 

   838 /****

   839  *SINT_TO_DATE

   840  */

   841     case function_sint_to_date :

   842     {

   843         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   844 

   845         {

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

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

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

   849             symbol_c *IN_type_symbol = NULL;

   850             

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

   852             if (IN_param_value == NULL)

   853               IN_param_value = function_call_param_iterator.next_nf();

   854             if (IN_param_value != NULL) {

   855               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   857             }

   858             

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

   860             {

   861         

   862                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   863                 return return_type_symbol;

   864                 

   865             }

   866             

   867             

   868             ERROR;

   869         }

   870         

   871     }/*function_sint_to_date*/

   872     break;

   873 

   874 /****

   875  *SINT_TO_DWORD

   876  */

   877     case function_sint_to_dword :

   878     {

   879         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   880 

   881         {

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

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

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

   885             symbol_c *IN_type_symbol = NULL;

   886             

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

   888             if (IN_param_value == NULL)

   889               IN_param_value = function_call_param_iterator.next_nf();

   890             if (IN_param_value != NULL) {

   891               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   893             }

   894             

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

   896             {

   897         

   898                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   899                 return return_type_symbol;

   900                 

   901             }

   902             

   903             

   904             ERROR;

   905         }

   906         

   907     }/*function_sint_to_dword*/

   908     break;

   909 

   910 /****

   911  *SINT_TO_DT

   912  */

   913     case function_sint_to_dt :

   914     {

   915         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   916 

   917         {

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

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

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

   921             symbol_c *IN_type_symbol = NULL;

   922             

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

   924             if (IN_param_value == NULL)

   925               IN_param_value = function_call_param_iterator.next_nf();

   926             if (IN_param_value != NULL) {

   927               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   929             }

   930             

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

   932             {

   933         

   934                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   935                 return return_type_symbol;

   936                 

   937             }

   938             

   939             

   940             ERROR;

   941         }

   942         

   943     }/*function_sint_to_dt*/

   944     break;

   945 

   946 /****

   947  *SINT_TO_TOD

   948  */

   949     case function_sint_to_tod :

   950     {

   951         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   952 

   953         {

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

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

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

   957             symbol_c *IN_type_symbol = NULL;

   958             

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

   960             if (IN_param_value == NULL)

   961               IN_param_value = function_call_param_iterator.next_nf();

   962             if (IN_param_value != NULL) {

   963               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

   965             }

   966             

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

   968             {

   969         

   970                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   971                 return return_type_symbol;

   972                 

   973             }

   974             

   975             

   976             ERROR;

   977         }

   978         

   979     }/*function_sint_to_tod*/

   980     break;

   981 

   982 /****

   983  *SINT_TO_UDINT

   984  */

   985     case function_sint_to_udint :

   986     {

   987         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

   988 

   989         {

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

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

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

   993             symbol_c *IN_type_symbol = NULL;

   994             

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

   996             if (IN_param_value == NULL)

   997               IN_param_value = function_call_param_iterator.next_nf();

   998             if (IN_param_value != NULL) {

   999               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

  1001             }

  1002             

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

  1004             {

  1005         

  1006                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

  1007                 return return_type_symbol;

  1008                 

  1009             }

  1010             

  1011             

  1012             ERROR;

  1013         }

  1014         

  1015     }/*function_sint_to_udint*/

  1016     break;

  1017 

  1018 /****

  1019  *SINT_TO_WORD

  1020  */

  1021     case function_sint_to_word :

  1022     {

  1023         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1024 

  1025         {

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

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

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

  1029             symbol_c *IN_type_symbol = NULL;

  1030             

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

  1032             if (IN_param_value == NULL)

  1033               IN_param_value = function_call_param_iterator.next_nf();

  1034             if (IN_param_value != NULL) {

  1035               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

  1037             }

  1038             

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

  1040             {

  1041         

  1042                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

  1043                 return return_type_symbol;

  1044                 

  1045             }

  1046             

  1047             

  1048             ERROR;

  1049         }

  1050         

  1051     }/*function_sint_to_word*/

  1052     break;

  1053 

  1054 /****

  1055  *SINT_TO_STRING

  1056  */

  1057     case function_sint_to_string :

  1058     {

  1059         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1060 

  1061         {

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

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

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

  1065             symbol_c *IN_type_symbol = NULL;

  1066             

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

  1068             if (IN_param_value == NULL)

  1069               IN_param_value = function_call_param_iterator.next_nf();

  1070             if (IN_param_value != NULL) {

  1071               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

  1073             }

  1074             

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

  1076             {

  1077         

  1078                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

  1079                 return return_type_symbol;

  1080                 

  1081             }

  1082             

  1083             

  1084             ERROR;

  1085         }

  1086         

  1087     }/*function_sint_to_string*/

  1088     break;

  1089 

  1090 /****

  1091  *SINT_TO_LWORD

  1092  */

  1093     case function_sint_to_lword :

  1094     {

  1095         symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;

  1096 

  1097         {

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

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

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

  1101             symbol_c *IN_type_symbol = NULL;

  1102             

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

  1104             if (IN_param_value == NULL)

  1105               IN_param_value = function_call_param_iterator.next_nf();

  1106             if (IN_param_value != NULL) {

  1107               IN_type_symbol = search_expression_type->get_type(IN_param_value);

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

  1109             }

  1110             

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

  1112             {

  1113         

  1114                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

  1115                 return return_type_symbol;

  1116                 

  1117             }

  1118             

  1119             

  1120             ERROR;

  1121         }

  1122         

  1123     }/*function_sint_to_lword*/

  1124     break;

  1125 

  1126 /****

  1127  *SINT_TO_UINT

  1128  */

  1129     case function_sint_to_uint :

  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 */