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             /* Get the value from a foo(<param_name> = <param_value>) style call */

    41             symbol_c *IN_param_value = &this->default_variable_name;

    42         

    43             symbol_c *IN_type_symbol = param_data_type;

    44             last_type_symbol = param_data_type;

    45             

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

    47             {

    48         

    49                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    50                 s4o.print("(");

    51                 return_type_symbol->accept(*this);

    52                 s4o.print(")");

    53                 IN_param_value->accept(*this);

    54                 return NULL;

    55                 

    56             }

    57             

    58             ERROR;

    59         }

    60         

    61     }/*function_bool_to_sint*/

    62     break;

    63 

    64 /****

    65  *BOOL_TO_INT

    66  */

    67     case function_bool_to_int :

    68     {

    69         symbol_c *last_type_symbol = NULL;

    70 

    71         {

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

    73             symbol_c *IN_param_value = &this->default_variable_name;

    74         

    75             symbol_c *IN_type_symbol = param_data_type;

    76             last_type_symbol = param_data_type;

    77             

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

    79             {

    80         

    81                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    82                 s4o.print("(");

    83                 return_type_symbol->accept(*this);

    84                 s4o.print(")");

    85                 IN_param_value->accept(*this);

    86                 return NULL;

    87                 

    88             }

    89             

    90             ERROR;

    91         }

    92         

    93     }/*function_bool_to_int*/

    94     break;

    95 

    96 /****

    97  *BOOL_TO_DINT

    98  */

    99     case function_bool_to_dint :

   100     {

   101         symbol_c *last_type_symbol = NULL;

   102 

   103         {

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

   105             symbol_c *IN_param_value = &this->default_variable_name;

   106         

   107             symbol_c *IN_type_symbol = param_data_type;

   108             last_type_symbol = param_data_type;

   109             

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

   111             {

   112         

   113                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   114                 s4o.print("(");

   115                 return_type_symbol->accept(*this);

   116                 s4o.print(")");

   117                 IN_param_value->accept(*this);

   118                 return NULL;

   119                 

   120             }

   121             

   122             ERROR;

   123         }

   124         

   125     }/*function_bool_to_dint*/

   126     break;

   127 

   128 /****

   129  *BOOL_TO_LINT

   130  */

   131     case function_bool_to_lint :

   132     {

   133         symbol_c *last_type_symbol = NULL;

   134 

   135         {

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

   137             symbol_c *IN_param_value = &this->default_variable_name;

   138         

   139             symbol_c *IN_type_symbol = param_data_type;

   140             last_type_symbol = param_data_type;

   141             

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

   143             {

   144         

   145                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   146                 s4o.print("(");

   147                 return_type_symbol->accept(*this);

   148                 s4o.print(")");

   149                 IN_param_value->accept(*this);

   150                 return NULL;

   151                 

   152             }

   153             

   154             ERROR;

   155         }

   156         

   157     }/*function_bool_to_lint*/

   158     break;

   159 

   160 /****

   161  *BOOL_TO_USINT

   162  */

   163     case function_bool_to_usint :

   164     {

   165         symbol_c *last_type_symbol = NULL;

   166 

   167         {

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

   169             symbol_c *IN_param_value = &this->default_variable_name;

   170         

   171             symbol_c *IN_type_symbol = param_data_type;

   172             last_type_symbol = param_data_type;

   173             

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

   175             {

   176         

   177                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   178                 s4o.print("(");

   179                 return_type_symbol->accept(*this);

   180                 s4o.print(")");

   181                 IN_param_value->accept(*this);

   182                 return NULL;

   183                 

   184             }

   185             

   186             ERROR;

   187         }

   188         

   189     }/*function_bool_to_usint*/

   190     break;

   191 

   192 /****

   193  *BOOL_TO_UINT

   194  */

   195     case function_bool_to_uint :

   196     {

   197         symbol_c *last_type_symbol = NULL;

   198 

   199         {

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

   201             symbol_c *IN_param_value = &this->default_variable_name;

   202         

   203             symbol_c *IN_type_symbol = param_data_type;

   204             last_type_symbol = param_data_type;

   205             

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

   207             {

   208         

   209                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   210                 s4o.print("(");

   211                 return_type_symbol->accept(*this);

   212                 s4o.print(")");

   213                 IN_param_value->accept(*this);

   214                 return NULL;

   215                 

   216             }

   217             

   218             ERROR;

   219         }

   220         

   221     }/*function_bool_to_uint*/

   222     break;

   223 

   224 /****

   225  *BOOL_TO_UDINT

   226  */

   227     case function_bool_to_udint :

   228     {

   229         symbol_c *last_type_symbol = NULL;

   230 

   231         {

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

   233             symbol_c *IN_param_value = &this->default_variable_name;

   234         

   235             symbol_c *IN_type_symbol = param_data_type;

   236             last_type_symbol = param_data_type;

   237             

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

   239             {

   240         

   241                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   242                 s4o.print("(");

   243                 return_type_symbol->accept(*this);

   244                 s4o.print(")");

   245                 IN_param_value->accept(*this);

   246                 return NULL;

   247                 

   248             }

   249             

   250             ERROR;

   251         }

   252         

   253     }/*function_bool_to_udint*/

   254     break;

   255 

   256 /****

   257  *BOOL_TO_ULINT

   258  */

   259     case function_bool_to_ulint :

   260     {

   261         symbol_c *last_type_symbol = NULL;

   262 

   263         {

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

   265             symbol_c *IN_param_value = &this->default_variable_name;

   266         

   267             symbol_c *IN_type_symbol = param_data_type;

   268             last_type_symbol = param_data_type;

   269             

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

   271             {

   272         

   273                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   274                 s4o.print("(");

   275                 return_type_symbol->accept(*this);

   276                 s4o.print(")");

   277                 IN_param_value->accept(*this);

   278                 return NULL;

   279                 

   280             }

   281             

   282             ERROR;

   283         }

   284         

   285     }/*function_bool_to_ulint*/

   286     break;

   287 

   288 /****

   289  *BOOL_TO_REAL

   290  */

   291     case function_bool_to_real :

   292     {

   293         symbol_c *last_type_symbol = NULL;

   294 

   295         {

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

   297             symbol_c *IN_param_value = &this->default_variable_name;

   298         

   299             symbol_c *IN_type_symbol = param_data_type;

   300             last_type_symbol = param_data_type;

   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::real_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_real*/

   318     break;

   319 

   320 /****

   321  *BOOL_TO_LREAL

   322  */

   323     case function_bool_to_lreal :

   324     {

   325         symbol_c *last_type_symbol = NULL;

   326 

   327         {

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

   329             symbol_c *IN_param_value = &this->default_variable_name;

   330         

   331             symbol_c *IN_type_symbol = param_data_type;

   332             last_type_symbol = param_data_type;

   333             

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

   335             {

   336         

   337                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   338                 s4o.print("(");

   339                 return_type_symbol->accept(*this);

   340                 s4o.print(")");

   341                 IN_param_value->accept(*this);

   342                 return NULL;

   343                 

   344             }

   345             

   346             ERROR;

   347         }

   348         

   349     }/*function_bool_to_lreal*/

   350     break;

   351 

   352 /****

   353  *BOOL_TO_TIME

   354  */

   355     case function_bool_to_time :

   356     {

   357         symbol_c *last_type_symbol = NULL;

   358 

   359         {

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

   361             symbol_c *IN_param_value = &this->default_variable_name;

   362         

   363             symbol_c *IN_type_symbol = param_data_type;

   364             last_type_symbol = param_data_type;

   365             

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

   367             {

   368         

   369                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   370                 s4o.print("(");

   371                 return_type_symbol->accept(*this);

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

   373                 IN_param_value->accept(*this);

   374                 s4o.print(")");

   375                 return NULL;

   376                 

   377             }

   378             

   379             ERROR;

   380         }

   381         

   382     }/*function_bool_to_time*/

   383     break;

   384 

   385 /****

   386  *BOOL_TO_DATE

   387  */

   388     case function_bool_to_date :

   389     {

   390         symbol_c *last_type_symbol = NULL;

   391 

   392         {

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

   394             symbol_c *IN_param_value = &this->default_variable_name;

   395         

   396             symbol_c *IN_type_symbol = param_data_type;

   397             last_type_symbol = param_data_type;

   398             

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

   400             {

   401         

   402                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   403                 s4o.print("(");

   404                 return_type_symbol->accept(*this);

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

   406                 IN_param_value->accept(*this);

   407                 s4o.print(")");

   408                 return NULL;

   409                 

   410             }

   411             

   412             ERROR;

   413         }

   414         

   415     }/*function_bool_to_date*/

   416     break;

   417 

   418 /****

   419  *BOOL_TO_TOD

   420  */

   421     case function_bool_to_tod :

   422     {

   423         symbol_c *last_type_symbol = NULL;

   424 

   425         {

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

   427             symbol_c *IN_param_value = &this->default_variable_name;

   428         

   429             symbol_c *IN_type_symbol = param_data_type;

   430             last_type_symbol = param_data_type;

   431             

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

   433             {

   434         

   435                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   436                 s4o.print("(");

   437                 return_type_symbol->accept(*this);

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

   439                 IN_param_value->accept(*this);

   440                 s4o.print(")");

   441                 return NULL;

   442                 

   443             }

   444             

   445             ERROR;

   446         }

   447         

   448     }/*function_bool_to_tod*/

   449     break;

   450 

   451 /****

   452  *BOOL_TO_DT

   453  */

   454     case function_bool_to_dt :

   455     {

   456         symbol_c *last_type_symbol = NULL;

   457 

   458         {

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

   460             symbol_c *IN_param_value = &this->default_variable_name;

   461         

   462             symbol_c *IN_type_symbol = param_data_type;

   463             last_type_symbol = param_data_type;

   464             

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

   466             {

   467         

   468                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   469                 s4o.print("(");

   470                 return_type_symbol->accept(*this);

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

   472                 IN_param_value->accept(*this);

   473                 s4o.print(")");

   474                 return NULL;

   475                 

   476             }

   477             

   478             ERROR;

   479         }

   480         

   481     }/*function_bool_to_dt*/

   482     break;

   483 

   484 /****

   485  *BOOL_TO_STRING

   486  */

   487     case function_bool_to_string :

   488     {

   489         symbol_c *last_type_symbol = NULL;

   490 

   491         {

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

   493             symbol_c *IN_param_value = &this->default_variable_name;

   494         

   495             symbol_c *IN_type_symbol = param_data_type;

   496             last_type_symbol = param_data_type;

   497             

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

   499             {

   500         

   501                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   502                 s4o.print("(");

   503                 return_type_symbol->accept(*this);

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

   505                 IN_param_value->accept(*this);

   506                 s4o.print(")");

   507                 return NULL;

   508                 

   509             }

   510             

   511             ERROR;

   512         }

   513         

   514     }/*function_bool_to_string*/

   515     break;

   516 

   517 /****

   518  *BOOL_TO_BYTE

   519  */

   520     case function_bool_to_byte :

   521     {

   522         symbol_c *last_type_symbol = NULL;

   523 

   524         {

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

   526             symbol_c *IN_param_value = &this->default_variable_name;

   527         

   528             symbol_c *IN_type_symbol = param_data_type;

   529             last_type_symbol = param_data_type;

   530             

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

   532             {

   533         

   534                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   535                 s4o.print("(");

   536                 return_type_symbol->accept(*this);

   537                 s4o.print(")");

   538                 IN_param_value->accept(*this);

   539                 return NULL;

   540                 

   541             }

   542             

   543             ERROR;

   544         }

   545         

   546     }/*function_bool_to_byte*/

   547     break;

   548 

   549 /****

   550  *BOOL_TO_WORD

   551  */

   552     case function_bool_to_word :

   553     {

   554         symbol_c *last_type_symbol = NULL;

   555 

   556         {

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

   558             symbol_c *IN_param_value = &this->default_variable_name;

   559         

   560             symbol_c *IN_type_symbol = param_data_type;

   561             last_type_symbol = param_data_type;

   562             

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

   564             {

   565         

   566                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   567                 s4o.print("(");

   568                 return_type_symbol->accept(*this);

   569                 s4o.print(")");

   570                 IN_param_value->accept(*this);

   571                 return NULL;

   572                 

   573             }

   574             

   575             ERROR;

   576         }

   577         

   578     }/*function_bool_to_word*/

   579     break;

   580 

   581 /****

   582  *BOOL_TO_DWORD

   583  */

   584     case function_bool_to_dword :

   585     {

   586         symbol_c *last_type_symbol = NULL;

   587 

   588         {

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

   590             symbol_c *IN_param_value = &this->default_variable_name;

   591         

   592             symbol_c *IN_type_symbol = param_data_type;

   593             last_type_symbol = param_data_type;

   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::dword_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_dword*/

   611     break;

   612 

   613 /****

   614  *BOOL_TO_LWORD

   615  */

   616     case function_bool_to_lword :

   617     {

   618         symbol_c *last_type_symbol = NULL;

   619 

   620         {

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

   622             symbol_c *IN_param_value = &this->default_variable_name;

   623         

   624             symbol_c *IN_type_symbol = param_data_type;

   625             last_type_symbol = param_data_type;

   626             

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

   628             {

   629         

   630                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   631                 s4o.print("(");

   632                 return_type_symbol->accept(*this);

   633                 s4o.print(")");

   634                 IN_param_value->accept(*this);

   635                 return NULL;

   636                 

   637             }

   638             

   639             ERROR;

   640         }

   641         

   642     }/*function_bool_to_lword*/

   643     break;

   644 

   645 /****

   646  *SINT_TO_BOOL

   647  */

   648     case function_sint_to_bool :

   649     {

   650         symbol_c *last_type_symbol = NULL;

   651 

   652         {

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

   654             symbol_c *IN_param_value = &this->default_variable_name;

   655         

   656             symbol_c *IN_type_symbol = param_data_type;

   657             last_type_symbol = param_data_type;

   658             

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

   660             {

   661         

   662                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   663                 s4o.print("(");

   664                 return_type_symbol->accept(*this);

   665                 s4o.print(")");

   666                 IN_param_value->accept(*this);

   667                 return NULL;

   668                 

   669             }

   670             

   671             ERROR;

   672         }

   673         

   674     }/*function_sint_to_bool*/

   675     break;

   676 

   677 /****

   678  *SINT_TO_INT

   679  */

   680     case function_sint_to_int :

   681     {

   682         symbol_c *last_type_symbol = NULL;

   683 

   684         {

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

   686             symbol_c *IN_param_value = &this->default_variable_name;

   687         

   688             symbol_c *IN_type_symbol = param_data_type;

   689             last_type_symbol = param_data_type;

   690             

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

   692             {

   693         

   694                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   695                 s4o.print("(");

   696                 return_type_symbol->accept(*this);

   697                 s4o.print(")");

   698                 IN_param_value->accept(*this);

   699                 return NULL;

   700                 

   701             }

   702             

   703             ERROR;

   704         }

   705         

   706     }/*function_sint_to_int*/

   707     break;

   708 

   709 /****

   710  *SINT_TO_DINT

   711  */

   712     case function_sint_to_dint :

   713     {

   714         symbol_c *last_type_symbol = NULL;

   715 

   716         {

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

   718             symbol_c *IN_param_value = &this->default_variable_name;

   719         

   720             symbol_c *IN_type_symbol = param_data_type;

   721             last_type_symbol = param_data_type;

   722             

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

   724             {

   725         

   726                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   727                 s4o.print("(");

   728                 return_type_symbol->accept(*this);

   729                 s4o.print(")");

   730                 IN_param_value->accept(*this);

   731                 return NULL;

   732                 

   733             }

   734             

   735             ERROR;

   736         }

   737         

   738     }/*function_sint_to_dint*/

   739     break;

   740 

   741 /****

   742  *SINT_TO_LINT

   743  */

   744     case function_sint_to_lint :

   745     {

   746         symbol_c *last_type_symbol = NULL;

   747 

   748         {

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

   750             symbol_c *IN_param_value = &this->default_variable_name;

   751         

   752             symbol_c *IN_type_symbol = param_data_type;

   753             last_type_symbol = param_data_type;

   754             

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

   756             {

   757         

   758                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   759                 s4o.print("(");

   760                 return_type_symbol->accept(*this);

   761                 s4o.print(")");

   762                 IN_param_value->accept(*this);

   763                 return NULL;

   764                 

   765             }

   766             

   767             ERROR;

   768         }

   769         

   770     }/*function_sint_to_lint*/

   771     break;

   772 

   773 /****

   774  *SINT_TO_USINT

   775  */

   776     case function_sint_to_usint :

   777     {

   778         symbol_c *last_type_symbol = NULL;

   779 

   780         {

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

   782             symbol_c *IN_param_value = &this->default_variable_name;

   783         

   784             symbol_c *IN_type_symbol = param_data_type;

   785             last_type_symbol = param_data_type;

   786             

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

   788             {

   789         

   790                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   791                 s4o.print("(");

   792                 return_type_symbol->accept(*this);

   793                 s4o.print(")");

   794                 IN_param_value->accept(*this);

   795                 return NULL;

   796                 

   797             }

   798             

   799             ERROR;

   800         }

   801         

   802     }/*function_sint_to_usint*/

   803     break;

   804 

   805 /****

   806  *SINT_TO_UINT

   807  */

   808     case function_sint_to_uint :

   809     {

   810         symbol_c *last_type_symbol = NULL;

   811 

   812         {

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

   814             symbol_c *IN_param_value = &this->default_variable_name;

   815         

   816             symbol_c *IN_type_symbol = param_data_type;

   817             last_type_symbol = param_data_type;

   818             

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

   820             {

   821         

   822                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   823                 s4o.print("(");

   824                 return_type_symbol->accept(*this);

   825                 s4o.print(")");

   826                 IN_param_value->accept(*this);

   827                 return NULL;

   828                 

   829             }

   830             

   831             ERROR;

   832         }

   833         

   834     }/*function_sint_to_uint*/

   835     break;

   836 

   837 /****

   838  *SINT_TO_UDINT

   839  */

   840     case function_sint_to_udint :

   841     {

   842         symbol_c *last_type_symbol = NULL;

   843 

   844         {

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

   846             symbol_c *IN_param_value = &this->default_variable_name;

   847         

   848             symbol_c *IN_type_symbol = param_data_type;

   849             last_type_symbol = param_data_type;

   850             

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

   852             {

   853         

   854                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   855                 s4o.print("(");

   856                 return_type_symbol->accept(*this);

   857                 s4o.print(")");

   858                 IN_param_value->accept(*this);

   859                 return NULL;

   860                 

   861             }

   862             

   863             ERROR;

   864         }

   865         

   866     }/*function_sint_to_udint*/

   867     break;

   868 

   869 /****

   870  *SINT_TO_ULINT

   871  */

   872     case function_sint_to_ulint :

   873     {

   874         symbol_c *last_type_symbol = NULL;

   875 

   876         {

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

   878             symbol_c *IN_param_value = &this->default_variable_name;

   879         

   880             symbol_c *IN_type_symbol = param_data_type;

   881             last_type_symbol = param_data_type;

   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::ulint_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_ulint*/

   899     break;

   900 

   901 /****

   902  *SINT_TO_REAL

   903  */

   904     case function_sint_to_real :

   905     {

   906         symbol_c *last_type_symbol = NULL;

   907 

   908         {

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

   910             symbol_c *IN_param_value = &this->default_variable_name;

   911         

   912             symbol_c *IN_type_symbol = param_data_type;

   913             last_type_symbol = param_data_type;

   914             

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

   916             {

   917         

   918                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   919                 s4o.print("(");

   920                 return_type_symbol->accept(*this);

   921                 s4o.print(")");

   922                 IN_param_value->accept(*this);

   923                 return NULL;

   924                 

   925             }

   926             

   927             ERROR;

   928         }

   929         

   930     }/*function_sint_to_real*/

   931     break;

   932 

   933 /****

   934  *SINT_TO_LREAL

   935  */

   936     case function_sint_to_lreal :

   937     {

   938         symbol_c *last_type_symbol = NULL;

   939 

   940         {

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

   942             symbol_c *IN_param_value = &this->default_variable_name;

   943         

   944             symbol_c *IN_type_symbol = param_data_type;

   945             last_type_symbol = param_data_type;

   946             

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

   948             {

   949         

   950                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   951                 s4o.print("(");

   952                 return_type_symbol->accept(*this);

   953                 s4o.print(")");

   954                 IN_param_value->accept(*this);

   955                 return NULL;

   956                 

   957             }

   958             

   959             ERROR;

   960         }

   961         

   962     }/*function_sint_to_lreal*/

   963     break;

   964 

   965 /****

   966  *SINT_TO_TIME

   967  */

   968     case function_sint_to_time :

   969     {

   970         symbol_c *last_type_symbol = NULL;

   971 

   972         {

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

   974             symbol_c *IN_param_value = &this->default_variable_name;

   975         

   976             symbol_c *IN_type_symbol = param_data_type;

   977             last_type_symbol = param_data_type;

   978             

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

   980             {

   981         

   982                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   983                 s4o.print("(");

   984                 return_type_symbol->accept(*this);

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

   986                 IN_param_value->accept(*this);

   987                 s4o.print(")");

   988                 return NULL;

   989                 

   990             }

   991             

   992             ERROR;

   993         }

   994         

   995     }/*function_sint_to_time*/

   996     break;

   997 

   998 /****

   999  *SINT_TO_DATE

  1000  */

  1001     case function_sint_to_date :

  1002     {

  1003         symbol_c *last_type_symbol = NULL;

  1004 

  1005         {

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

  1007             symbol_c *IN_param_value = &this->default_variable_name;

  1008         

  1009             symbol_c *IN_type_symbol = param_data_type;

  1010             last_type_symbol = param_data_type;

  1011             

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

  1013             {

  1014         

  1015                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

  1016                 s4o.print("(");

  1017                 return_type_symbol->accept(*this);

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

  1019                 IN_param_value->accept(*this);

  1020                 s4o.print(")");

  1021                 return NULL;

  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             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1040             symbol_c *IN_param_value = &this->default_variable_name;

  1041         

  1042             symbol_c *IN_type_symbol = param_data_type;

  1043             last_type_symbol = param_data_type;

  1044             

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

  1046             {

  1047         

  1048                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

  1049                 s4o.print("(");

  1050                 return_type_symbol->accept(*this);

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

  1052                 IN_param_value->accept(*this);

  1053                 s4o.print(")");

  1054                 return NULL;

  1055                 

  1056             }

  1057             

  1058             ERROR;

  1059         }

  1060         

  1061     }/*function_sint_to_tod*/

  1062     break;

  1063 

  1064 /****

  1065  *SINT_TO_DT

  1066  */

  1067     case function_sint_to_dt :

  1068     {

  1069         symbol_c *last_type_symbol = NULL;

  1070 

  1071         {

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

  1073             symbol_c *IN_param_value = &this->default_variable_name;

  1074         

  1075             symbol_c *IN_type_symbol = param_data_type;

  1076             last_type_symbol = param_data_type;

  1077             

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

  1079             {

  1080         

  1081                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

  1082                 s4o.print("(");

  1083                 return_type_symbol->accept(*this);

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

  1085                 IN_param_value->accept(*this);

  1086                 s4o.print(")");

  1087                 return NULL;

  1088                 

  1089             }

  1090             

  1091             ERROR;

  1092         }

  1093         

  1094     }/*function_sint_to_dt*/

  1095     break;

  1096 

  1097 /****

  1098  *SINT_TO_STRING

  1099  */

  1100     case function_sint_to_string :

  1101     {

  1102         symbol_c *last_type_symbol = NULL;

  1103 

  1104         {

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

  1106             symbol_c *IN_param_value = &this->default_variable_name;

  1107         

  1108             symbol_c *IN_type_symbol = param_data_type;

  1109             last_type_symbol = param_data_type;

  1110             

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

  1112             {

  1113         

  1114                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

  1115                 s4o.print("(");

  1116                 return_type_symbol->accept(*this);

  1117                 s4o.print(")__sint_to_string(");

  1118                 IN_param_value->accept(*this);

  1119                 s4o.print(")");

  1120                 return NULL;

  1121                 

  1122             }

  1123             

  1124             ERROR;

  1125         }

  1126         

  1127     }/*function_sint_to_string*/

  1128     break;

  1129 

  1130 /****

  1131  *SINT_TO_BYTE

  1132  */

  1133     case function_sint_to_byte :

  1134     {

  1135         symbol_c *last_type_symbol = NULL;

  1136