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 switch(current_function_type){

    31 

    32 /****

    33  *BOOL_TO_SINT

    34  */

    35     case function_bool_to_sint :

    36     {

    37         symbol_c *last_type_symbol = NULL;

    38 

    39         {

    40             identifier_c param_name("IN");

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

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

    43             

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

    45             if (IN_param_value == NULL)

    46               IN_param_value = function_call_param_iterator.next();

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

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

    49             

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

    51             {

    52         

    53                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    54                 s4o.print("(");

    55                 return_type_symbol->accept(*this);

    56                 s4o.print(")");

    57                 IN_param_value->accept(*this);

    58                 return NULL;

    59                 

    60             }

    61             

    62             ERROR;

    63         }

    64         

    65     }/*function_bool_to_sint*/

    66     break;

    67 

    68 /****

    69  *BOOL_TO_INT

    70  */

    71     case function_bool_to_int :

    72     {

    73         symbol_c *last_type_symbol = NULL;

    74 

    75         {

    76             identifier_c param_name("IN");

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

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

    79             

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

    81             if (IN_param_value == NULL)

    82               IN_param_value = function_call_param_iterator.next();

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

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

    85             

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

    87             {

    88         

    89                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    90                 s4o.print("(");

    91                 return_type_symbol->accept(*this);

    92                 s4o.print(")");

    93                 IN_param_value->accept(*this);

    94                 return NULL;

    95                 

    96             }

    97             

    98             ERROR;

    99         }

   100         

   101     }/*function_bool_to_int*/

   102     break;

   103 

   104 /****

   105  *BOOL_TO_DINT

   106  */

   107     case function_bool_to_dint :

   108     {

   109         symbol_c *last_type_symbol = NULL;

   110 

   111         {

   112             identifier_c param_name("IN");

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

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

   115             

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

   117             if (IN_param_value == NULL)

   118               IN_param_value = function_call_param_iterator.next();

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

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

   121             

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

   123             {

   124         

   125                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   126                 s4o.print("(");

   127                 return_type_symbol->accept(*this);

   128                 s4o.print(")");

   129                 IN_param_value->accept(*this);

   130                 return NULL;

   131                 

   132             }

   133             

   134             ERROR;

   135         }

   136         

   137     }/*function_bool_to_dint*/

   138     break;

   139 

   140 /****

   141  *BOOL_TO_LINT

   142  */

   143     case function_bool_to_lint :

   144     {

   145         symbol_c *last_type_symbol = NULL;

   146 

   147         {

   148             identifier_c param_name("IN");

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

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

   151             

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

   153             if (IN_param_value == NULL)

   154               IN_param_value = function_call_param_iterator.next();

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

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

   157             

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

   159             {

   160         

   161                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   162                 s4o.print("(");

   163                 return_type_symbol->accept(*this);

   164                 s4o.print(")");

   165                 IN_param_value->accept(*this);

   166                 return NULL;

   167                 

   168             }

   169             

   170             ERROR;

   171         }

   172         

   173     }/*function_bool_to_lint*/

   174     break;

   175 

   176 /****

   177  *BOOL_TO_USINT

   178  */

   179     case function_bool_to_usint :

   180     {

   181         symbol_c *last_type_symbol = NULL;

   182 

   183         {

   184             identifier_c param_name("IN");

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

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

   187             

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

   189             if (IN_param_value == NULL)

   190               IN_param_value = function_call_param_iterator.next();

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

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

   193             

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

   195             {

   196         

   197                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   198                 s4o.print("(");

   199                 return_type_symbol->accept(*this);

   200                 s4o.print(")");

   201                 IN_param_value->accept(*this);

   202                 return NULL;

   203                 

   204             }

   205             

   206             ERROR;

   207         }

   208         

   209     }/*function_bool_to_usint*/

   210     break;

   211 

   212 /****

   213  *BOOL_TO_UINT

   214  */

   215     case function_bool_to_uint :

   216     {

   217         symbol_c *last_type_symbol = NULL;

   218 

   219         {

   220             identifier_c param_name("IN");

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

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

   223             

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

   225             if (IN_param_value == NULL)

   226               IN_param_value = function_call_param_iterator.next();

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

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

   229             

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

   231             {

   232         

   233                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   234                 s4o.print("(");

   235                 return_type_symbol->accept(*this);

   236                 s4o.print(")");

   237                 IN_param_value->accept(*this);

   238                 return NULL;

   239                 

   240             }

   241             

   242             ERROR;

   243         }

   244         

   245     }/*function_bool_to_uint*/

   246     break;

   247 

   248 /****

   249  *BOOL_TO_UDINT

   250  */

   251     case function_bool_to_udint :

   252     {

   253         symbol_c *last_type_symbol = NULL;

   254 

   255         {

   256             identifier_c param_name("IN");

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

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

   259             

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

   261             if (IN_param_value == NULL)

   262               IN_param_value = function_call_param_iterator.next();

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

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

   265             

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

   267             {

   268         

   269                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   270                 s4o.print("(");

   271                 return_type_symbol->accept(*this);

   272                 s4o.print(")");

   273                 IN_param_value->accept(*this);

   274                 return NULL;

   275                 

   276             }

   277             

   278             ERROR;

   279         }

   280         

   281     }/*function_bool_to_udint*/

   282     break;

   283 

   284 /****

   285  *BOOL_TO_ULINT

   286  */

   287     case function_bool_to_ulint :

   288     {

   289         symbol_c *last_type_symbol = NULL;

   290 

   291         {

   292             identifier_c param_name("IN");

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

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

   295             

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

   297             if (IN_param_value == NULL)

   298               IN_param_value = function_call_param_iterator.next();

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

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

   301             

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

   303             {

   304         

   305                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   306                 s4o.print("(");

   307                 return_type_symbol->accept(*this);

   308                 s4o.print(")");

   309                 IN_param_value->accept(*this);

   310                 return NULL;

   311                 

   312             }

   313             

   314             ERROR;

   315         }

   316         

   317     }/*function_bool_to_ulint*/

   318     break;

   319 

   320 /****

   321  *BOOL_TO_REAL

   322  */

   323     case function_bool_to_real :

   324     {

   325         symbol_c *last_type_symbol = NULL;

   326 

   327         {

   328             identifier_c param_name("IN");

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

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

   331             

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

   333             if (IN_param_value == NULL)

   334               IN_param_value = function_call_param_iterator.next();

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

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

   337             

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

   339             {

   340         

   341                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   342                 s4o.print("(");

   343                 return_type_symbol->accept(*this);

   344                 s4o.print(")");

   345                 IN_param_value->accept(*this);

   346                 return NULL;

   347                 

   348             }

   349             

   350             ERROR;

   351         }

   352         

   353     }/*function_bool_to_real*/

   354     break;

   355 

   356 /****

   357  *BOOL_TO_LREAL

   358  */

   359     case function_bool_to_lreal :

   360     {

   361         symbol_c *last_type_symbol = NULL;

   362 

   363         {

   364             identifier_c param_name("IN");

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

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

   367             

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

   369             if (IN_param_value == NULL)

   370               IN_param_value = function_call_param_iterator.next();

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

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

   373             

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

   375             {

   376         

   377                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   378                 s4o.print("(");

   379                 return_type_symbol->accept(*this);

   380                 s4o.print(")");

   381                 IN_param_value->accept(*this);

   382                 return NULL;

   383                 

   384             }

   385             

   386             ERROR;

   387         }

   388         

   389     }/*function_bool_to_lreal*/

   390     break;

   391 

   392 /****

   393  *BOOL_TO_TIME

   394  */

   395     case function_bool_to_time :

   396     {

   397         symbol_c *last_type_symbol = NULL;

   398 

   399         {

   400             identifier_c param_name("IN");

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

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

   403             

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

   405             if (IN_param_value == NULL)

   406               IN_param_value = function_call_param_iterator.next();

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

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

   409             

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

   411             {

   412         

   413                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   414                 s4o.print("(");

   415                 return_type_symbol->accept(*this);

   416                 s4o.print(")__int_to_time(");

   417                 IN_param_value->accept(*this);

   418                 s4o.print(")");

   419                 return NULL;

   420                 

   421             }

   422             

   423             ERROR;

   424         }

   425         

   426     }/*function_bool_to_time*/

   427     break;

   428 

   429 /****

   430  *BOOL_TO_DATE

   431  */

   432     case function_bool_to_date :

   433     {

   434         symbol_c *last_type_symbol = NULL;

   435 

   436         {

   437             identifier_c param_name("IN");

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

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

   440             

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

   442             if (IN_param_value == NULL)

   443               IN_param_value = function_call_param_iterator.next();

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

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

   446             

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

   448             {

   449         

   450                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   451                 s4o.print("(");

   452                 return_type_symbol->accept(*this);

   453                 s4o.print(")__int_to_time(");

   454                 IN_param_value->accept(*this);

   455                 s4o.print(")");

   456                 return NULL;

   457                 

   458             }

   459             

   460             ERROR;

   461         }

   462         

   463     }/*function_bool_to_date*/

   464     break;

   465 

   466 /****

   467  *BOOL_TO_TOD

   468  */

   469     case function_bool_to_tod :

   470     {

   471         symbol_c *last_type_symbol = NULL;

   472 

   473         {

   474             identifier_c param_name("IN");

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

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

   477             

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

   479             if (IN_param_value == NULL)

   480               IN_param_value = function_call_param_iterator.next();

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

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

   483             

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

   485             {

   486         

   487                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   488                 s4o.print("(");

   489                 return_type_symbol->accept(*this);

   490                 s4o.print(")__int_to_time(");

   491                 IN_param_value->accept(*this);

   492                 s4o.print(")");

   493                 return NULL;

   494                 

   495             }

   496             

   497             ERROR;

   498         }

   499         

   500     }/*function_bool_to_tod*/

   501     break;

   502 

   503 /****

   504  *BOOL_TO_DT

   505  */

   506     case function_bool_to_dt :

   507     {

   508         symbol_c *last_type_symbol = NULL;

   509 

   510         {

   511             identifier_c param_name("IN");

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

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

   514             

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

   516             if (IN_param_value == NULL)

   517               IN_param_value = function_call_param_iterator.next();

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

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

   520             

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

   522             {

   523         

   524                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   525                 s4o.print("(");

   526                 return_type_symbol->accept(*this);

   527                 s4o.print(")__int_to_time(");

   528                 IN_param_value->accept(*this);

   529                 s4o.print(")");

   530                 return NULL;

   531                 

   532             }

   533             

   534             ERROR;

   535         }

   536         

   537     }/*function_bool_to_dt*/

   538     break;

   539 

   540 /****

   541  *BOOL_TO_STRING

   542  */

   543     case function_bool_to_string :

   544     {

   545         symbol_c *last_type_symbol = NULL;

   546 

   547         {

   548             identifier_c param_name("IN");

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

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

   551             

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

   553             if (IN_param_value == NULL)

   554               IN_param_value = function_call_param_iterator.next();

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

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

   557             

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

   559             {

   560         

   561                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   562                 s4o.print("(");

   563                 return_type_symbol->accept(*this);

   564                 s4o.print(")__bool_to_string(");

   565                 IN_param_value->accept(*this);

   566                 s4o.print(")");

   567                 return NULL;

   568                 

   569             }

   570             

   571             ERROR;

   572         }

   573         

   574     }/*function_bool_to_string*/

   575     break;

   576 

   577 /****

   578  *BOOL_TO_BYTE

   579  */

   580     case function_bool_to_byte :

   581     {

   582         symbol_c *last_type_symbol = NULL;

   583 

   584         {

   585             identifier_c param_name("IN");

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

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

   588             

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

   590             if (IN_param_value == NULL)

   591               IN_param_value = function_call_param_iterator.next();

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

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

   594             

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

   596             {

   597         

   598                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   599                 s4o.print("(");

   600                 return_type_symbol->accept(*this);

   601                 s4o.print(")");

   602                 IN_param_value->accept(*this);

   603                 return NULL;

   604                 

   605             }

   606             

   607             ERROR;

   608         }

   609         

   610     }/*function_bool_to_byte*/

   611     break;

   612 

   613 /****

   614  *BOOL_TO_WORD

   615  */

   616     case function_bool_to_word :

   617     {

   618         symbol_c *last_type_symbol = NULL;

   619 

   620         {

   621             identifier_c param_name("IN");

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

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

   624             

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

   626             if (IN_param_value == NULL)

   627               IN_param_value = function_call_param_iterator.next();

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

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

   630             

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

   632             {

   633         

   634                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   635                 s4o.print("(");

   636                 return_type_symbol->accept(*this);

   637                 s4o.print(")");

   638                 IN_param_value->accept(*this);

   639                 return NULL;

   640                 

   641             }

   642             

   643             ERROR;

   644         }

   645         

   646     }/*function_bool_to_word*/

   647     break;

   648 

   649 /****

   650  *BOOL_TO_DWORD

   651  */

   652     case function_bool_to_dword :

   653     {

   654         symbol_c *last_type_symbol = NULL;

   655 

   656         {

   657             identifier_c param_name("IN");

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

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

   660             

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

   662             if (IN_param_value == NULL)

   663               IN_param_value = function_call_param_iterator.next();

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

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

   666             

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

   668             {

   669         

   670                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   671                 s4o.print("(");

   672                 return_type_symbol->accept(*this);

   673                 s4o.print(")");

   674                 IN_param_value->accept(*this);

   675                 return NULL;

   676                 

   677             }

   678             

   679             ERROR;

   680         }

   681         

   682     }/*function_bool_to_dword*/

   683     break;

   684 

   685 /****

   686  *BOOL_TO_LWORD

   687  */

   688     case function_bool_to_lword :

   689     {

   690         symbol_c *last_type_symbol = NULL;

   691 

   692         {

   693             identifier_c param_name("IN");

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

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

   696             

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

   698             if (IN_param_value == NULL)

   699               IN_param_value = function_call_param_iterator.next();

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

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

   702             

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

   704             {

   705         

   706                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   707                 s4o.print("(");

   708                 return_type_symbol->accept(*this);

   709                 s4o.print(")");

   710                 IN_param_value->accept(*this);

   711                 return NULL;

   712                 

   713             }

   714             

   715             ERROR;

   716         }

   717         

   718     }/*function_bool_to_lword*/

   719     break;

   720 

   721 /****

   722  *SINT_TO_BOOL

   723  */

   724     case function_sint_to_bool :

   725     {

   726         symbol_c *last_type_symbol = NULL;

   727 

   728         {

   729             identifier_c param_name("IN");

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

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

   732             

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

   734             if (IN_param_value == NULL)

   735               IN_param_value = function_call_param_iterator.next();

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

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

   738             

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

   740             {

   741         

   742                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   743                 s4o.print("(");

   744                 return_type_symbol->accept(*this);

   745                 s4o.print(")");

   746                 IN_param_value->accept(*this);

   747                 return NULL;

   748                 

   749             }

   750             

   751             ERROR;

   752         }

   753         

   754     }/*function_sint_to_bool*/

   755     break;

   756 

   757 /****

   758  *SINT_TO_INT

   759  */

   760     case function_sint_to_int :

   761     {

   762         symbol_c *last_type_symbol = NULL;

   763 

   764         {

   765             identifier_c param_name("IN");

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

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

   768             

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

   770             if (IN_param_value == NULL)

   771               IN_param_value = function_call_param_iterator.next();

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

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

   774             

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

   776             {

   777         

   778                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   779                 s4o.print("(");

   780                 return_type_symbol->accept(*this);

   781                 s4o.print(")");

   782                 IN_param_value->accept(*this);

   783                 return NULL;

   784                 

   785             }

   786             

   787             ERROR;

   788         }

   789         

   790     }/*function_sint_to_int*/

   791     break;

   792 

   793 /****

   794  *SINT_TO_DINT

   795  */

   796     case function_sint_to_dint :

   797     {

   798         symbol_c *last_type_symbol = NULL;

   799 

   800         {

   801             identifier_c param_name("IN");

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

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

   804             

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

   806             if (IN_param_value == NULL)

   807               IN_param_value = function_call_param_iterator.next();

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

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

   810             

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

   812             {

   813         

   814                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   815                 s4o.print("(");

   816                 return_type_symbol->accept(*this);

   817                 s4o.print(")");

   818                 IN_param_value->accept(*this);

   819                 return NULL;

   820                 

   821             }

   822             

   823             ERROR;

   824         }

   825         

   826     }/*function_sint_to_dint*/

   827     break;

   828 

   829 /****

   830  *SINT_TO_LINT

   831  */

   832     case function_sint_to_lint :

   833     {

   834         symbol_c *last_type_symbol = NULL;

   835 

   836         {

   837             identifier_c param_name("IN");

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

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

   840             

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

   842             if (IN_param_value == NULL)

   843               IN_param_value = function_call_param_iterator.next();

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

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

   846             

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

   848             {

   849         

   850                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   851                 s4o.print("(");

   852                 return_type_symbol->accept(*this);

   853                 s4o.print(")");

   854                 IN_param_value->accept(*this);

   855                 return NULL;

   856                 

   857             }

   858             

   859             ERROR;

   860         }

   861         

   862     }/*function_sint_to_lint*/

   863     break;

   864 

   865 /****

   866  *SINT_TO_USINT

   867  */

   868     case function_sint_to_usint :

   869     {

   870         symbol_c *last_type_symbol = NULL;

   871 

   872         {

   873             identifier_c param_name("IN");

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

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

   876             

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

   878             if (IN_param_value == NULL)

   879               IN_param_value = function_call_param_iterator.next();

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

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

   882             

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

   884             {

   885         

   886                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   887                 s4o.print("(");

   888                 return_type_symbol->accept(*this);

   889                 s4o.print(")");

   890                 IN_param_value->accept(*this);

   891                 return NULL;

   892                 

   893             }

   894             

   895             ERROR;

   896         }

   897         

   898     }/*function_sint_to_usint*/

   899     break;

   900 

   901 /****

   902  *SINT_TO_UINT

   903  */

   904     case function_sint_to_uint :

   905     {

   906         symbol_c *last_type_symbol = NULL;

   907 

   908         {

   909             identifier_c param_name("IN");

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

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

   912             

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

   914             if (IN_param_value == NULL)

   915               IN_param_value = function_call_param_iterator.next();

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

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

   918             

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

   920             {

   921         

   922                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   923                 s4o.print("(");

   924                 return_type_symbol->accept(*this);

   925                 s4o.print(")");

   926                 IN_param_value->accept(*this);

   927                 return NULL;

   928                 

   929             }

   930             

   931             ERROR;

   932         }

   933         

   934     }/*function_sint_to_uint*/

   935     break;

   936 

   937 /****

   938  *SINT_TO_UDINT

   939  */

   940     case function_sint_to_udint :

   941     {

   942         symbol_c *last_type_symbol = NULL;

   943 

   944         {

   945             identifier_c param_name("IN");

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

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

   948             

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

   950             if (IN_param_value == NULL)

   951               IN_param_value = function_call_param_iterator.next();

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

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

   954             

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

   956             {

   957         

   958                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   959                 s4o.print("(");

   960                 return_type_symbol->accept(*this);

   961                 s4o.print(")");

   962                 IN_param_value->accept(*this);

   963                 return NULL;

   964                 

   965             }

   966             

   967             ERROR;

   968         }

   969         

   970     }/*function_sint_to_udint*/

   971     break;

   972 

   973 /****

   974  *SINT_TO_ULINT

   975  */

   976     case function_sint_to_ulint :

   977     {

   978         symbol_c *last_type_symbol = NULL;

   979 

   980         {

   981             identifier_c param_name("IN");

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

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

   984             

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

   986             if (IN_param_value == NULL)

   987               IN_param_value = function_call_param_iterator.next();

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

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

   990             

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

   992             {

   993         

   994                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   995                 s4o.print("(");

   996                 return_type_symbol->accept(*this);

   997                 s4o.print(")");

   998                 IN_param_value->accept(*this);

   999                 return NULL;

  1000                 

  1001             }

  1002             

  1003             ERROR;

  1004         }

  1005         

  1006     }/*function_sint_to_ulint*/

  1007     break;

  1008 

  1009 /****

  1010  *SINT_TO_REAL

  1011  */

  1012     case function_sint_to_real :

  1013     {

  1014         symbol_c *last_type_symbol = NULL;

  1015 

  1016         {

  1017             identifier_c param_name("IN");

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

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

  1020             

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

  1022             if (IN_param_value == NULL)

  1023               IN_param_value = function_call_param_iterator.next();

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

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

  1026             

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

  1028             {

  1029         

  1030                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

  1031                 s4o.print("(");

  1032                 return_type_symbol->accept(*this);

  1033                 s4o.print(")");

  1034                 IN_param_value->accept(*this);

  1035                 return NULL;

  1036                 

  1037             }

  1038             

  1039             ERROR;

  1040         }

  1041         

  1042     }/*function_sint_to_real*/

  1043     break;

  1044 

  1045 /****

  1046  *SINT_TO_LREAL

  1047  */

  1048     case function_sint_to_lreal :

  1049     {

  1050         symbol_c *last_type_symbol = NULL;

  1051 

  1052         {

  1053             identifier_c param_name("IN");

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

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

  1056             

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

  1058             if (IN_param_value == NULL)

  1059               IN_param_value = function_call_param_iterator.next();

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

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

  1062             

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

  1064             {

  1065         

  1066                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

  1067                 s4o.print("(");

  1068                 return_type_symbol->accept(*this);

  1069                 s4o.print(")");

  1070                 IN_param_value->accept(*this);

  1071                 return NULL;

  1072                 

  1073             }

  1074             

  1075             ERROR;

  1076         }

  1077         

  1078     }/*function_sint_to_lreal*/

  1079     break;

  1080 

  1081 /****

  1082  *SINT_TO_TIME

  1083  */

  1084     case function_sint_to_time :

  1085     {

  1086         symbol_c *last_type_symbol = NULL;

  1087 

  1088         {

  1089             identifier_c param_name("IN");

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

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

  1092             

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

  1094             if (IN_param_value == NULL)

  1095               IN_param_value = function_call_param_iterator.next();

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

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

  1098             

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

  1100             {

  1101         

  1102                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

  1103                 s4o.print("(");

  1104                 return_type_symbol->accept(*this);

  1105                 s4o.print(")__int_to_time(");

  1106                 IN_param_value->accept(*this);

  1107                 s4o.print(")");

  1108                 return NULL;

  1109                 

  1110             }

  1111             

  1112             ERROR;

  1113         }

  1114         

  1115     }/*function_sint_to_time*/

  1116     break;

  1117 

  1118 /****

  1119  *SINT_TO_DATE

  1120  */

  1121     case function_sint_to_date :

  1122     {

  1123         symbol_c *last_type_symbol = NULL;

  1124 

  1125         {

  1126             identifier_c param_name("IN");

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

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

  1129             

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

  1131             if (IN_param_value == NULL)

  1132               IN_param_value = function_call_param_iterator.next();

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

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

  1135             

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