1 /*

     2  * (c) 2003 Mario de Sousa

     3  *

     4  * Offered to the public under the terms of the GNU General Public License

     5  * as published by the Free Software Foundation; either version 2 of the

     6  * License, or (at your option) any later version.

     7  *

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

     9  * WITHOUT ANY WARRANTY; without even the implied warranty of

    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11  * Public License for more details.

    12  *

    13  * This code is made available on the understanding that it will not be

    14  * used in safety-critical situations without a full and competent review.

    15  */

    16 

    17 /*

    18  * An IEC 61131-3 IL and ST compiler.

    19  *

    20  * Based on the

    21  * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22  *

    23  */

    24  

    25  

    26 /****

    27  * IEC 61131-3 standard function lib

    28  * generated code, do not edit by hand

    29  */

    30 

    31 void *compute_standard_function_st(function_invocation_c *symbol) {

    32 

    33   function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);

    34   function_call_param_iterator_c function_call_param_iterator(symbol);

    35   search_expression_type_c* search_expression_type = this;

    36 

    37   switch(current_function_type){

    38 

    39 /****

    40  *BOOL_TO_SINT

    41  */

    42     case function_bool_to_sint :

    43     {

    44         symbol_c *last_type_symbol = NULL;

    45 

    46         {

    47             identifier_c param_name("IN");

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

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

    50             

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

    52             if (IN_param_value == NULL)

    53               IN_param_value = function_call_param_iterator.next();

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

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

    56             

    57             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

    58             {

    59         

    60                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    61                 return return_type_symbol;

    62                 

    63             }

    64             

    65             ERROR;

    66         }

    67         

    68     }/*function_bool_to_sint*/

    69     break;

    70 

    71 /****

    72  *BOOL_TO_INT

    73  */

    74     case function_bool_to_int :

    75     {

    76         symbol_c *last_type_symbol = NULL;

    77 

    78         {

    79             identifier_c param_name("IN");

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

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

    82             

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

    84             if (IN_param_value == NULL)

    85               IN_param_value = function_call_param_iterator.next();

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

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

    88             

    89             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

    90             {

    91         

    92                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    93                 return return_type_symbol;

    94                 

    95             }

    96             

    97             ERROR;

    98         }

    99         

   100     }/*function_bool_to_int*/

   101     break;

   102 

   103 /****

   104  *BOOL_TO_DINT

   105  */

   106     case function_bool_to_dint :

   107     {

   108         symbol_c *last_type_symbol = NULL;

   109 

   110         {

   111             identifier_c param_name("IN");

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

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

   114             

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

   116             if (IN_param_value == NULL)

   117               IN_param_value = function_call_param_iterator.next();

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

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

   120             

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

   122             {

   123         

   124                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   125                 return return_type_symbol;

   126                 

   127             }

   128             

   129             ERROR;

   130         }

   131         

   132     }/*function_bool_to_dint*/

   133     break;

   134 

   135 /****

   136  *BOOL_TO_LINT

   137  */

   138     case function_bool_to_lint :

   139     {

   140         symbol_c *last_type_symbol = NULL;

   141 

   142         {

   143             identifier_c param_name("IN");

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

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

   146             

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

   148             if (IN_param_value == NULL)

   149               IN_param_value = function_call_param_iterator.next();

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

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

   152             

   153             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   154             {

   155         

   156                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   157                 return return_type_symbol;

   158                 

   159             }

   160             

   161             ERROR;

   162         }

   163         

   164     }/*function_bool_to_lint*/

   165     break;

   166 

   167 /****

   168  *BOOL_TO_USINT

   169  */

   170     case function_bool_to_usint :

   171     {

   172         symbol_c *last_type_symbol = NULL;

   173 

   174         {

   175             identifier_c param_name("IN");

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

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

   178             

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

   180             if (IN_param_value == NULL)

   181               IN_param_value = function_call_param_iterator.next();

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

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

   184             

   185             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   186             {

   187         

   188                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   189                 return return_type_symbol;

   190                 

   191             }

   192             

   193             ERROR;

   194         }

   195         

   196     }/*function_bool_to_usint*/

   197     break;

   198 

   199 /****

   200  *BOOL_TO_UINT

   201  */

   202     case function_bool_to_uint :

   203     {

   204         symbol_c *last_type_symbol = NULL;

   205 

   206         {

   207             identifier_c param_name("IN");

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

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

   210             

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

   212             if (IN_param_value == NULL)

   213               IN_param_value = function_call_param_iterator.next();

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

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

   216             

   217             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   218             {

   219         

   220                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   221                 return return_type_symbol;

   222                 

   223             }

   224             

   225             ERROR;

   226         }

   227         

   228     }/*function_bool_to_uint*/

   229     break;

   230 

   231 /****

   232  *BOOL_TO_UDINT

   233  */

   234     case function_bool_to_udint :

   235     {

   236         symbol_c *last_type_symbol = NULL;

   237 

   238         {

   239             identifier_c param_name("IN");

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

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

   242             

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

   244             if (IN_param_value == NULL)

   245               IN_param_value = function_call_param_iterator.next();

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

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

   248             

   249             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   250             {

   251         

   252                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   253                 return return_type_symbol;

   254                 

   255             }

   256             

   257             ERROR;

   258         }

   259         

   260     }/*function_bool_to_udint*/

   261     break;

   262 

   263 /****

   264  *BOOL_TO_ULINT

   265  */

   266     case function_bool_to_ulint :

   267     {

   268         symbol_c *last_type_symbol = NULL;

   269 

   270         {

   271             identifier_c param_name("IN");

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

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

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

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

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

   280             

   281             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   282             {

   283         

   284                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   285                 return return_type_symbol;

   286                 

   287             }

   288             

   289             ERROR;

   290         }

   291         

   292     }/*function_bool_to_ulint*/

   293     break;

   294 

   295 /****

   296  *BOOL_TO_REAL

   297  */

   298     case function_bool_to_real :

   299     {

   300         symbol_c *last_type_symbol = NULL;

   301 

   302         {

   303             identifier_c param_name("IN");

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

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

   306             

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

   308             if (IN_param_value == NULL)

   309               IN_param_value = function_call_param_iterator.next();

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

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

   312             

   313             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   314             {

   315         

   316                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   317                 return return_type_symbol;

   318                 

   319             }

   320             

   321             ERROR;

   322         }

   323         

   324     }/*function_bool_to_real*/

   325     break;

   326 

   327 /****

   328  *BOOL_TO_LREAL

   329  */

   330     case function_bool_to_lreal :

   331     {

   332         symbol_c *last_type_symbol = NULL;

   333 

   334         {

   335             identifier_c param_name("IN");

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

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

   338             

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

   340             if (IN_param_value == NULL)

   341               IN_param_value = function_call_param_iterator.next();

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

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

   344             

   345             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   346             {

   347         

   348                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   349                 return return_type_symbol;

   350                 

   351             }

   352             

   353             ERROR;

   354         }

   355         

   356     }/*function_bool_to_lreal*/

   357     break;

   358 

   359 /****

   360  *BOOL_TO_TIME

   361  */

   362     case function_bool_to_time :

   363     {

   364         symbol_c *last_type_symbol = NULL;

   365 

   366         {

   367             identifier_c param_name("IN");

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

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

   370             

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

   372             if (IN_param_value == NULL)

   373               IN_param_value = function_call_param_iterator.next();

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

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

   376             

   377             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   378             {

   379         

   380                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   381                 return return_type_symbol;

   382                 

   383             }

   384             

   385             ERROR;

   386         }

   387         

   388     }/*function_bool_to_time*/

   389     break;

   390 

   391 /****

   392  *BOOL_TO_DATE

   393  */

   394     case function_bool_to_date :

   395     {

   396         symbol_c *last_type_symbol = NULL;

   397 

   398         {

   399             identifier_c param_name("IN");

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

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

   402             

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

   404             if (IN_param_value == NULL)

   405               IN_param_value = function_call_param_iterator.next();

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

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

   408             

   409             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   410             {

   411         

   412                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   413                 return return_type_symbol;

   414                 

   415             }

   416             

   417             ERROR;

   418         }

   419         

   420     }/*function_bool_to_date*/

   421     break;

   422 

   423 /****

   424  *BOOL_TO_TOD

   425  */

   426     case function_bool_to_tod :

   427     {

   428         symbol_c *last_type_symbol = NULL;

   429 

   430         {

   431             identifier_c param_name("IN");

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

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

   434             

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

   436             if (IN_param_value == NULL)

   437               IN_param_value = function_call_param_iterator.next();

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

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

   440             

   441             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   442             {

   443         

   444                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   445                 return return_type_symbol;

   446                 

   447             }

   448             

   449             ERROR;

   450         }

   451         

   452     }/*function_bool_to_tod*/

   453     break;

   454 

   455 /****

   456  *BOOL_TO_DT

   457  */

   458     case function_bool_to_dt :

   459     {

   460         symbol_c *last_type_symbol = NULL;

   461 

   462         {

   463             identifier_c param_name("IN");

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

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

   466             

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

   468             if (IN_param_value == NULL)

   469               IN_param_value = function_call_param_iterator.next();

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

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

   472             

   473             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   474             {

   475         

   476                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   477                 return return_type_symbol;

   478                 

   479             }

   480             

   481             ERROR;

   482         }

   483         

   484     }/*function_bool_to_dt*/

   485     break;

   486 

   487 /****

   488  *BOOL_TO_STRING

   489  */

   490     case function_bool_to_string :

   491     {

   492         symbol_c *last_type_symbol = NULL;

   493 

   494         {

   495             identifier_c param_name("IN");

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

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

   498             

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

   500             if (IN_param_value == NULL)

   501               IN_param_value = function_call_param_iterator.next();

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

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

   504             

   505             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   506             {

   507         

   508                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   509                 return return_type_symbol;

   510                 

   511             }

   512             

   513             ERROR;

   514         }

   515         

   516     }/*function_bool_to_string*/

   517     break;

   518 

   519 /****

   520  *BOOL_TO_BYTE

   521  */

   522     case function_bool_to_byte :

   523     {

   524         symbol_c *last_type_symbol = NULL;

   525 

   526         {

   527             identifier_c param_name("IN");

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

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

   530             

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

   532             if (IN_param_value == NULL)

   533               IN_param_value = function_call_param_iterator.next();

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

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

   536             

   537             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   538             {

   539         

   540                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   541                 return return_type_symbol;

   542                 

   543             }

   544             

   545             ERROR;

   546         }

   547         

   548     }/*function_bool_to_byte*/

   549     break;

   550 

   551 /****

   552  *BOOL_TO_WORD

   553  */

   554     case function_bool_to_word :

   555     {

   556         symbol_c *last_type_symbol = NULL;

   557 

   558         {

   559             identifier_c param_name("IN");

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

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

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

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

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

   568             

   569             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   570             {

   571         

   572                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   573                 return return_type_symbol;

   574                 

   575             }

   576             

   577             ERROR;

   578         }

   579         

   580     }/*function_bool_to_word*/

   581     break;

   582 

   583 /****

   584  *BOOL_TO_DWORD

   585  */

   586     case function_bool_to_dword :

   587     {

   588         symbol_c *last_type_symbol = NULL;

   589 

   590         {

   591             identifier_c param_name("IN");

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

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

   594             

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

   596             if (IN_param_value == NULL)

   597               IN_param_value = function_call_param_iterator.next();

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

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

   600             

   601             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   602             {

   603         

   604                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   605                 return return_type_symbol;

   606                 

   607             }

   608             

   609             ERROR;

   610         }

   611         

   612     }/*function_bool_to_dword*/

   613     break;

   614 

   615 /****

   616  *BOOL_TO_LWORD

   617  */

   618     case function_bool_to_lword :

   619     {

   620         symbol_c *last_type_symbol = NULL;

   621 

   622         {

   623             identifier_c param_name("IN");

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

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

   626             

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

   628             if (IN_param_value == NULL)

   629               IN_param_value = function_call_param_iterator.next();

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

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

   632             

   633             if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   634             {

   635         

   636                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   637                 return return_type_symbol;

   638                 

   639             }

   640             

   641             ERROR;

   642         }

   643         

   644     }/*function_bool_to_lword*/

   645     break;

   646 

   647 /****

   648  *SINT_TO_BOOL

   649  */

   650     case function_sint_to_bool :

   651     {

   652         symbol_c *last_type_symbol = NULL;

   653 

   654         {

   655             identifier_c param_name("IN");

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

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

   658             

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

   660             if (IN_param_value == NULL)

   661               IN_param_value = function_call_param_iterator.next();

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

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

   664             

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

   666             {

   667         

   668                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   669                 return return_type_symbol;

   670                 

   671             }

   672             

   673             ERROR;

   674         }

   675         

   676     }/*function_sint_to_bool*/

   677     break;

   678 

   679 /****

   680  *SINT_TO_INT

   681  */

   682     case function_sint_to_int :

   683     {

   684         symbol_c *last_type_symbol = NULL;

   685 

   686         {

   687             identifier_c param_name("IN");

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

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

   690             

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

   692             if (IN_param_value == NULL)

   693               IN_param_value = function_call_param_iterator.next();

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

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

   696             

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

   698             {

   699         

   700                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   701                 return return_type_symbol;

   702                 

   703             }

   704             

   705             ERROR;

   706         }

   707         

   708     }/*function_sint_to_int*/

   709     break;

   710 

   711 /****

   712  *SINT_TO_DINT

   713  */

   714     case function_sint_to_dint :

   715     {

   716         symbol_c *last_type_symbol = NULL;

   717 

   718         {

   719             identifier_c param_name("IN");

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

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

   722             

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

   724             if (IN_param_value == NULL)

   725               IN_param_value = function_call_param_iterator.next();

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

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

   728             

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

   730             {

   731         

   732                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   733                 return return_type_symbol;

   734                 

   735             }

   736             

   737             ERROR;

   738         }

   739         

   740     }/*function_sint_to_dint*/

   741     break;

   742 

   743 /****

   744  *SINT_TO_LINT

   745  */

   746     case function_sint_to_lint :

   747     {

   748         symbol_c *last_type_symbol = NULL;

   749 

   750         {

   751             identifier_c param_name("IN");

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

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

   754             

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

   756             if (IN_param_value == NULL)

   757               IN_param_value = function_call_param_iterator.next();

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

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

   760             

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

   762             {

   763         

   764                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   765                 return return_type_symbol;

   766                 

   767             }

   768             

   769             ERROR;

   770         }

   771         

   772     }/*function_sint_to_lint*/

   773     break;

   774 

   775 /****

   776  *SINT_TO_USINT

   777  */

   778     case function_sint_to_usint :

   779     {

   780         symbol_c *last_type_symbol = NULL;

   781 

   782         {

   783             identifier_c param_name("IN");

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

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

   786             

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

   788             if (IN_param_value == NULL)

   789               IN_param_value = function_call_param_iterator.next();

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

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

   792             

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

   794             {

   795         

   796                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   797                 return return_type_symbol;

   798                 

   799             }

   800             

   801             ERROR;

   802         }

   803         

   804     }/*function_sint_to_usint*/

   805     break;

   806 

   807 /****

   808  *SINT_TO_UINT

   809  */

   810     case function_sint_to_uint :

   811     {

   812         symbol_c *last_type_symbol = NULL;

   813 

   814         {

   815             identifier_c param_name("IN");

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

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

   818             

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

   820             if (IN_param_value == NULL)

   821               IN_param_value = function_call_param_iterator.next();

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

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

   824             

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

   826             {

   827         

   828                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   829                 return return_type_symbol;

   830                 

   831             }

   832             

   833             ERROR;

   834         }

   835         

   836     }/*function_sint_to_uint*/

   837     break;

   838 

   839 /****

   840  *SINT_TO_UDINT

   841  */

   842     case function_sint_to_udint :

   843     {

   844         symbol_c *last_type_symbol = NULL;

   845 

   846         {

   847             identifier_c param_name("IN");

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

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

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

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

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

   856             

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

   858             {

   859         

   860                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   861                 return return_type_symbol;

   862                 

   863             }

   864             

   865             ERROR;

   866         }

   867         

   868     }/*function_sint_to_udint*/

   869     break;

   870 

   871 /****

   872  *SINT_TO_ULINT

   873  */

   874     case function_sint_to_ulint :

   875     {

   876         symbol_c *last_type_symbol = NULL;

   877 

   878         {

   879             identifier_c param_name("IN");

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

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

   882             

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

   884             if (IN_param_value == NULL)

   885               IN_param_value = function_call_param_iterator.next();

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

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

   888             

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

   890             {

   891         

   892                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   893                 return return_type_symbol;

   894                 

   895             }

   896             

   897             ERROR;

   898         }

   899         

   900     }/*function_sint_to_ulint*/

   901     break;

   902 

   903 /****

   904  *SINT_TO_REAL

   905  */

   906     case function_sint_to_real :

   907     {

   908         symbol_c *last_type_symbol = NULL;

   909 

   910         {

   911             identifier_c param_name("IN");

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

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

   914             

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

   916             if (IN_param_value == NULL)

   917               IN_param_value = function_call_param_iterator.next();

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

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

   920             

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

   922             {

   923         

   924                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   925                 return return_type_symbol;

   926                 

   927             }

   928             

   929             ERROR;

   930         }

   931         

   932     }/*function_sint_to_real*/

   933     break;

   934 

   935 /****

   936  *SINT_TO_LREAL

   937  */

   938     case function_sint_to_lreal :

   939     {

   940         symbol_c *last_type_symbol = NULL;

   941 

   942         {

   943             identifier_c param_name("IN");

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

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

   946             

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

   948             if (IN_param_value == NULL)

   949               IN_param_value = function_call_param_iterator.next();

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

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

   952             

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

   954             {

   955         

   956                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   957                 return return_type_symbol;

   958                 

   959             }

   960             

   961             ERROR;

   962         }

   963         

   964     }/*function_sint_to_lreal*/

   965     break;

   966 

   967 /****

   968  *SINT_TO_TIME

   969  */

   970     case function_sint_to_time :

   971     {

   972         symbol_c *last_type_symbol = NULL;

   973 

   974         {

   975             identifier_c param_name("IN");

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

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

   978             

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

   980             if (IN_param_value == NULL)

   981               IN_param_value = function_call_param_iterator.next();

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

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

   984             

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

   986             {

   987         

   988                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   989                 return return_type_symbol;

   990                 

   991             }

   992             

   993             ERROR;

   994         }

   995         

   996     }/*function_sint_to_time*/

   997     break;

   998 

   999 /****

  1000  *SINT_TO_DATE

  1001  */

  1002     case function_sint_to_date :

  1003     {

  1004         symbol_c *last_type_symbol = NULL;

  1005 

  1006         {

  1007             identifier_c param_name("IN");

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

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

  1010             

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

  1012             if (IN_param_value == NULL)

  1013               IN_param_value = function_call_param_iterator.next();

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

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

  1016             

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

  1018             {

  1019         

  1020                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

  1021                 return return_type_symbol;

  1022                 

  1023             }

  1024             

  1025             ERROR;

  1026         }

  1027         

  1028     }/*function_sint_to_date*/

  1029     break;

  1030 

  1031 /****

  1032  *SINT_TO_TOD

  1033  */

  1034     case function_sint_to_tod :

  1035     {

  1036         symbol_c *last_type_symbol = NULL;

  1037 

  1038         {

  1039             identifier_c param_name("IN");

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

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

  1042             

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

  1044             if (IN_param_value == NULL)

  1045               IN_param_value = function_call_param_iterator.next();

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

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

  1048             

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

  1050             {

  1051         

  1052                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

  1053                 return return_type_symbol;

  1054                 

  1055             }

  1056             

  1057             ERROR;

  1058         }

  1059         

  1060     }/*function_sint_to_tod*/

  1061     break;

  1062 

  1063 /****

  1064  *SINT_TO_DT

  1065  */

  1066     case function_sint_to_dt :

  1067     {

  1068         symbol_c *last_type_symbol = NULL;

  1069 

  1070         {

  1071             identifier_c param_name("IN");

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

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

  1074             

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

  1076             if (IN_param_value == NULL)

  1077               IN_param_value = function_call_param_iterator.next();

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

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

  1080             

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

  1082             {

  1083         

  1084                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

  1085                 return return_type_symbol;

  1086                 

  1087             }

  1088             

  1089             ERROR;

  1090         }

  1091         

  1092     }/*function_sint_to_dt*/

  1093     break;

  1094 

  1095 /****

  1096  *SINT_TO_STRING

  1097  */

  1098     case function_sint_to_string :

  1099     {

  1100         symbol_c *last_type_symbol = NULL;

  1101 

  1102         {

  1103             identifier_c param_name("IN");

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

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

  1106             

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

  1108             if (IN_param_value == NULL)

  1109               IN_param_value = function_call_param_iterator.next();

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

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

  1112             

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

  1114             {

  1115         

  1116                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

  1117                 return return_type_symbol;

  1118                 

  1119             }

  1120             

  1121             ERROR;

  1122         }

  1123         

  1124     }/*function_sint_to_string*/

  1125     break;

  1126 

  1127 /****

  1128  *SINT_TO_BYTE

  1129  */

  1130     case function_sint_to_byte :

  1131     {

  1132         symbol_c *last_type_symbol = NULL;

  1133 

  1134         {

  1135             identifier_c param_name("IN");

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