9  *BOOL_TO_SINT

    10  */

    11     case function_bool_to_sint :

    12     {

    13         symbol_c *last_type_symbol = NULL;

    14 

    15         {

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

    17             symbol_c *IN_param_value = &this->default_variable_name;

    18         

    19             symbol_c *IN_type_symbol = param_data_type;

    20             last_type_symbol = param_data_type;

    21             

    22             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

    23             {

    24         

    25                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    26                 s4o.print("(");

    27                 return_type_symbol->accept(*this);

    28                 s4o.print(")");

    29                 IN_param_value->accept(*this);

    30                 return NULL;

    31                 

    32             }

    33             

    34             ERROR;

    35         }

    36         

    37     }/*function_bool_to_sint*/

    38     break;

    39 

    40 /****

    41  *BOOL_TO_INT

    42  */

    43     case function_bool_to_int :

    44     {

    45         symbol_c *last_type_symbol = NULL;

    46 

    47         {

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

    49             symbol_c *IN_param_value = &this->default_variable_name;

    50         

    51             symbol_c *IN_type_symbol = param_data_type;

    52             last_type_symbol = param_data_type;

    53             

    54             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

    55             {

    56         

    57                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    58                 s4o.print("(");

    59                 return_type_symbol->accept(*this);

    60                 s4o.print(")");

    61                 IN_param_value->accept(*this);

    62                 return NULL;

    63                 

    64             }

    65             

    66             ERROR;

    67         }

    68         

    69     }/*function_bool_to_int*/

    70     break;

    71 

    72 /****

    73  *BOOL_TO_DINT

    74  */

    75     case function_bool_to_dint :

    76     {

    77         symbol_c *last_type_symbol = NULL;

    78 

    79         {

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

    81             symbol_c *IN_param_value = &this->default_variable_name;

    82         

    83             symbol_c *IN_type_symbol = param_data_type;

    84             last_type_symbol = param_data_type;

    85             

    86             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

    87             {

    88         

    89                 symbol_c * return_type_symbol = &search_constant_type_c::dint_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_dint*/

   102     break;

   103 

   104 /****

   105  *BOOL_TO_LINT

   106  */

   107     case function_bool_to_lint :

   108     {

   109         symbol_c *last_type_symbol = NULL;

   110 

   111         {

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

   113             symbol_c *IN_param_value = &this->default_variable_name;

   114         

   115             symbol_c *IN_type_symbol = param_data_type;

   116             last_type_symbol = param_data_type;

   117             

   118             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   119             {

   120         

   121                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   122                 s4o.print("(");

   123                 return_type_symbol->accept(*this);

   124                 s4o.print(")");

   125                 IN_param_value->accept(*this);

   126                 return NULL;

   127                 

   128             }

   129             

   130             ERROR;

   131         }

   132         

   133     }/*function_bool_to_lint*/

   134     break;

   135 

   136 /****

   137  *BOOL_TO_USINT

   138  */

   139     case function_bool_to_usint :

   140     {

   141         symbol_c *last_type_symbol = NULL;

   142 

   143         {

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

   145             symbol_c *IN_param_value = &this->default_variable_name;

   146         

   147             symbol_c *IN_type_symbol = param_data_type;

   148             last_type_symbol = param_data_type;

   149             

   150             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   151             {

   152         

   153                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   154                 s4o.print("(");

   155                 return_type_symbol->accept(*this);

   156                 s4o.print(")");

   157                 IN_param_value->accept(*this);

   158                 return NULL;

   159                 

   160             }

   161             

   162             ERROR;

   163         }

   164         

   165     }/*function_bool_to_usint*/

   166     break;

   167 

   168 /****

   169  *BOOL_TO_UINT

   170  */

   171     case function_bool_to_uint :

   172     {

   173         symbol_c *last_type_symbol = NULL;

   174 

   175         {

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

   177             symbol_c *IN_param_value = &this->default_variable_name;

   178         

   179             symbol_c *IN_type_symbol = param_data_type;

   180             last_type_symbol = param_data_type;

   181             

   182             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   183             {

   184         

   185                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   186                 s4o.print("(");

   187                 return_type_symbol->accept(*this);

   188                 s4o.print(")");

   189                 IN_param_value->accept(*this);

   190                 return NULL;

   191                 

   192             }

   193             

   194             ERROR;

   195         }

   196         

   197     }/*function_bool_to_uint*/

   198     break;

   199 

   200 /****

   201  *BOOL_TO_UDINT

   202  */

   203     case function_bool_to_udint :

   204     {

   205         symbol_c *last_type_symbol = NULL;

   206 

   207         {

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

   209             symbol_c *IN_param_value = &this->default_variable_name;

   210         

   211             symbol_c *IN_type_symbol = param_data_type;

   212             last_type_symbol = param_data_type;

   213             

   214             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   215             {

   216         

   217                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   218                 s4o.print("(");

   219                 return_type_symbol->accept(*this);

   220                 s4o.print(")");

   221                 IN_param_value->accept(*this);

   222                 return NULL;

   223                 

   224             }

   225             

   226             ERROR;

   227         }

   228         

   229     }/*function_bool_to_udint*/

   230     break;

   231 

   232 /****

   233  *BOOL_TO_ULINT

   234  */

   235     case function_bool_to_ulint :

   236     {

   237         symbol_c *last_type_symbol = NULL;

   238 

   239         {

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

   241             symbol_c *IN_param_value = &this->default_variable_name;

   242         

   243             symbol_c *IN_type_symbol = param_data_type;

   244             last_type_symbol = param_data_type;

   245             

   246             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   247             {

   248         

   249                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   250                 s4o.print("(");

   251                 return_type_symbol->accept(*this);

   252                 s4o.print(")");

   253                 IN_param_value->accept(*this);

   254                 return NULL;

   255                 

   256             }

   257             

   258             ERROR;

   259         }

   260         

   261     }/*function_bool_to_ulint*/

   262     break;

   263 

   264 /****

   265  *BOOL_TO_REAL

   266  */

   267     case function_bool_to_real :

   268     {

   269         symbol_c *last_type_symbol = NULL;

   270 

   271         {

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

   273             symbol_c *IN_param_value = &this->default_variable_name;

   274         

   275             symbol_c *IN_type_symbol = param_data_type;

   276             last_type_symbol = param_data_type;

   277             

   278             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   279             {

   280         

   281                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   282                 s4o.print("(");

   283                 return_type_symbol->accept(*this);

   284                 s4o.print(")");

   285                 IN_param_value->accept(*this);

   286                 return NULL;

   287                 

   288             }

   289             

   290             ERROR;

   291         }

   292         

   293     }/*function_bool_to_real*/

   294     break;

   295 

   296 /****

   297  *BOOL_TO_LREAL

   298  */

   299     case function_bool_to_lreal :

   300     {

   301         symbol_c *last_type_symbol = NULL;

   302 

   303         {

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

   305             symbol_c *IN_param_value = &this->default_variable_name;

   306         

   307             symbol_c *IN_type_symbol = param_data_type;

   308             last_type_symbol = param_data_type;

   309             

   310             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   311             {

   312         

   313                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   314                 s4o.print("(");

   315                 return_type_symbol->accept(*this);

   316                 s4o.print(")");

   317                 IN_param_value->accept(*this);

   318                 return NULL;

   319                 

   320             }

   321             

   322             ERROR;

   323         }

   324         

   325     }/*function_bool_to_lreal*/

   326     break;

   327 

   328 /****

   329  *BOOL_TO_TIME

   330  */

   331     case function_bool_to_time :

   332     {

   333         symbol_c *last_type_symbol = NULL;

   334 

   335         {

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

   337             symbol_c *IN_param_value = &this->default_variable_name;

   338         

   339             symbol_c *IN_type_symbol = param_data_type;

   340             last_type_symbol = param_data_type;

   341             

   342             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   343             {

   344         

   345                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   346                 s4o.print("(");

   347                 return_type_symbol->accept(*this);

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

   349                 IN_param_value->accept(*this);

   350                 s4o.print(")");

   351                 return NULL;

   352                 

   353             }

   354             

   355             ERROR;

   356         }

   357         

   358     }/*function_bool_to_time*/

   359     break;

   360 

   361 /****

   362  *BOOL_TO_DATE

   363  */

   364     case function_bool_to_date :

   365     {

   366         symbol_c *last_type_symbol = NULL;

   367 

   368         {

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

   370             symbol_c *IN_param_value = &this->default_variable_name;

   371         

   372             symbol_c *IN_type_symbol = param_data_type;

   373             last_type_symbol = param_data_type;

   374             

   375             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   376             {

   377         

   378                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   379                 s4o.print("(");

   380                 return_type_symbol->accept(*this);

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

   382                 IN_param_value->accept(*this);

   383                 s4o.print(")");

   384                 return NULL;

   385                 

   386             }

   387             

   388             ERROR;

   389         }

   390         

   391     }/*function_bool_to_date*/

   392     break;

   393 

   394 /****

   395  *BOOL_TO_TOD

   396  */

   397     case function_bool_to_tod :

   398     {

   399         symbol_c *last_type_symbol = NULL;

   400 

   401         {

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

   403             symbol_c *IN_param_value = &this->default_variable_name;

   404         

   405             symbol_c *IN_type_symbol = param_data_type;

   406             last_type_symbol = param_data_type;

   407             

   408             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   409             {

   410         

   411                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   412                 s4o.print("(");

   413                 return_type_symbol->accept(*this);

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

   415                 IN_param_value->accept(*this);

   416                 s4o.print(")");

   417                 return NULL;

   418                 

   419             }

   420             

   421             ERROR;

   422         }

   423         

   424     }/*function_bool_to_tod*/

   425     break;

   426 

   427 /****

   428  *BOOL_TO_DT

   429  */

   430     case function_bool_to_dt :

   431     {

   432         symbol_c *last_type_symbol = NULL;

   433 

   434         {

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

   436             symbol_c *IN_param_value = &this->default_variable_name;

   437         

   438             symbol_c *IN_type_symbol = param_data_type;

   439             last_type_symbol = param_data_type;

   440             

   441             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   442             {

   443         

   444                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   445                 s4o.print("(");

   446                 return_type_symbol->accept(*this);

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

   448                 IN_param_value->accept(*this);

   449                 s4o.print(")");

   450                 return NULL;

   451                 

   452             }

   453             

   454             ERROR;

   455         }

   456         

   457     }/*function_bool_to_dt*/

   458     break;

   459 

   460 /****

   461  *BOOL_TO_STRING

   462  */

   463     case function_bool_to_string :

   464     {

   465         symbol_c *last_type_symbol = NULL;

   466 

   467         {

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

   469             symbol_c *IN_param_value = &this->default_variable_name;

   470         

   471             symbol_c *IN_type_symbol = param_data_type;

   472             last_type_symbol = param_data_type;

   473             

   474             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   475             {

   476         

   477                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   478                 s4o.print("(");

   479                 return_type_symbol->accept(*this);

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

   481                 IN_param_value->accept(*this);

   482                 s4o.print(")");

   483                 return NULL;

   484                 

   485             }

   486             

   487             ERROR;

   488         }

   489         

   490     }/*function_bool_to_string*/

   491     break;

   492 

   493 /****

   494  *BOOL_TO_BYTE

   495  */

   496     case function_bool_to_byte :

   497     {

   498         symbol_c *last_type_symbol = NULL;

   499 

   500         {

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

   502             symbol_c *IN_param_value = &this->default_variable_name;

   503         

   504             symbol_c *IN_type_symbol = param_data_type;

   505             last_type_symbol = param_data_type;

   506             

   507             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   508             {

   509         

   510                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   511                 s4o.print("(");

   512                 return_type_symbol->accept(*this);

   513                 s4o.print(")");

   514                 IN_param_value->accept(*this);

   515                 return NULL;

   516                 

   517             }

   518             

   519             ERROR;

   520         }

   521         

   522     }/*function_bool_to_byte*/

   523     break;

   524 

   525 /****

   526  *BOOL_TO_WORD

   527  */

   528     case function_bool_to_word :

   529     {

   530         symbol_c *last_type_symbol = NULL;

   531 

   532         {

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

   534             symbol_c *IN_param_value = &this->default_variable_name;

   535         

   536             symbol_c *IN_type_symbol = param_data_type;

   537             last_type_symbol = param_data_type;

   538             

   539             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   540             {

   541         

   542                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   543                 s4o.print("(");

   544                 return_type_symbol->accept(*this);

   545                 s4o.print(")");

   546                 IN_param_value->accept(*this);

   547                 return NULL;

   548                 

   549             }

   550             

   551             ERROR;

   552         }

   553         

   554     }/*function_bool_to_word*/

   555     break;

   556 

   557 /****

   558  *BOOL_TO_DWORD

   559  */

   560     case function_bool_to_dword :

   561     {

   562         symbol_c *last_type_symbol = NULL;

   563 

   564         {

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

   566             symbol_c *IN_param_value = &this->default_variable_name;

   567         

   568             symbol_c *IN_type_symbol = param_data_type;

   569             last_type_symbol = param_data_type;

   570             

   571             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   572             {

   573         

   574                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   575                 s4o.print("(");

   576                 return_type_symbol->accept(*this);

   577                 s4o.print(")");

   578                 IN_param_value->accept(*this);

   579                 return NULL;

   580                 

   581             }

   582             

   583             ERROR;

   584         }

   585         

   586     }/*function_bool_to_dword*/

   587     break;

   588 

   589 /****

   590  *BOOL_TO_LWORD

   591  */

   592     case function_bool_to_lword :

   593     {

   594         symbol_c *last_type_symbol = NULL;

   595 

   596         {

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

   598             symbol_c *IN_param_value = &this->default_variable_name;

   599         

   600             symbol_c *IN_type_symbol = param_data_type;

   601             last_type_symbol = param_data_type;

   602             

   603             if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   604             {

   605         

   606                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   607                 s4o.print("(");

   608                 return_type_symbol->accept(*this);

   609                 s4o.print(")");

   610                 IN_param_value->accept(*this);

   611                 return NULL;

   612                 

   613             }

   614             

   615             ERROR;

   616         }

   617         

   618     }/*function_bool_to_lword*/

   619     break;

   620 

   621 /****

   622  *SINT_TO_BOOL

   623  */

   624     case function_sint_to_bool :

   625     {

   626         symbol_c *last_type_symbol = NULL;

   627 

   628         {

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

   630             symbol_c *IN_param_value = &this->default_variable_name;

   631         

   632             symbol_c *IN_type_symbol = param_data_type;

   633             last_type_symbol = param_data_type;

   634             

   635             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   636             {

   637         

   638                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   639                 s4o.print("(");

   640                 return_type_symbol->accept(*this);

   641                 s4o.print(")");

   642                 IN_param_value->accept(*this);

   643                 return NULL;

   644                 

   645             }

   646             

   647             ERROR;

   648         }

   649         

   650     }/*function_sint_to_bool*/

   651     break;

   652 

   653 /****

   654  *SINT_TO_INT

   655  */

   656     case function_sint_to_int :

   657     {

   658         symbol_c *last_type_symbol = NULL;

   659 

   660         {

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

   662             symbol_c *IN_param_value = &this->default_variable_name;

   663         

   664             symbol_c *IN_type_symbol = param_data_type;

   665             last_type_symbol = param_data_type;

   666             

   667             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   668             {

   669         

   670                 symbol_c * return_type_symbol = &search_constant_type_c::int_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_sint_to_int*/

   683     break;

   684 

   685 /****

   686  *SINT_TO_DINT

   687  */

   688     case function_sint_to_dint :

   689     {

   690         symbol_c *last_type_symbol = NULL;

   691 

   692         {

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

   694             symbol_c *IN_param_value = &this->default_variable_name;

   695         

   696             symbol_c *IN_type_symbol = param_data_type;

   697             last_type_symbol = param_data_type;

   698             

   699             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   700             {

   701         

   702                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   703                 s4o.print("(");

   704                 return_type_symbol->accept(*this);

   705                 s4o.print(")");

   706                 IN_param_value->accept(*this);

   707                 return NULL;

   708                 

   709             }

   710             

   711             ERROR;

   712         }

   713         

   714     }/*function_sint_to_dint*/

   715     break;

   716 

   717 /****

   718  *SINT_TO_LINT

   719  */

   720     case function_sint_to_lint :

   721     {

   722         symbol_c *last_type_symbol = NULL;

   723 

   724         {

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

   726             symbol_c *IN_param_value = &this->default_variable_name;

   727         

   728             symbol_c *IN_type_symbol = param_data_type;

   729             last_type_symbol = param_data_type;

   730             

   731             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   732             {

   733         

   734                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   735                 s4o.print("(");

   736                 return_type_symbol->accept(*this);

   737                 s4o.print(")");

   738                 IN_param_value->accept(*this);

   739                 return NULL;

   740                 

   741             }

   742             

   743             ERROR;

   744         }

   745         

   746     }/*function_sint_to_lint*/

   747     break;

   748 

   749 /****

   750  *SINT_TO_USINT

   751  */

   752     case function_sint_to_usint :

   753     {

   754         symbol_c *last_type_symbol = NULL;

   755 

   756         {

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

   758             symbol_c *IN_param_value = &this->default_variable_name;

   759         

   760             symbol_c *IN_type_symbol = param_data_type;

   761             last_type_symbol = param_data_type;

   762             

   763             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   764             {

   765         

   766                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   767                 s4o.print("(");

   768                 return_type_symbol->accept(*this);

   769                 s4o.print(")");

   770                 IN_param_value->accept(*this);

   771                 return NULL;

   772                 

   773             }

   774             

   775             ERROR;

   776         }

   777         

   778     }/*function_sint_to_usint*/

   779     break;

   780 

   781 /****

   782  *SINT_TO_UINT

   783  */

   784     case function_sint_to_uint :

   785     {

   786         symbol_c *last_type_symbol = NULL;

   787 

   788         {

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

   790             symbol_c *IN_param_value = &this->default_variable_name;

   791         

   792             symbol_c *IN_type_symbol = param_data_type;

   793             last_type_symbol = param_data_type;

   794             

   795             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   796             {

   797         

   798                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   799                 s4o.print("(");

   800                 return_type_symbol->accept(*this);

   801                 s4o.print(")");

   802                 IN_param_value->accept(*this);

   803                 return NULL;

   804                 

   805             }

   806             

   807             ERROR;

   808         }

   809         

   810     }/*function_sint_to_uint*/

   811     break;

   812 

   813 /****

   814  *SINT_TO_UDINT

   815  */

   816     case function_sint_to_udint :

   817     {

   818         symbol_c *last_type_symbol = NULL;

   819 

   820         {

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

   822             symbol_c *IN_param_value = &this->default_variable_name;

   823         

   824             symbol_c *IN_type_symbol = param_data_type;

   825             last_type_symbol = param_data_type;

   826             

   827             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   828             {

   829         

   830                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   831                 s4o.print("(");

   832                 return_type_symbol->accept(*this);

   833                 s4o.print(")");

   834                 IN_param_value->accept(*this);

   835                 return NULL;

   836                 

   837             }

   838             

   839             ERROR;

   840         }

   841         

   842     }/*function_sint_to_udint*/

   843     break;

   844 

   845 /****

   846  *SINT_TO_ULINT

   847  */

   848     case function_sint_to_ulint :

   849     {

   850         symbol_c *last_type_symbol = NULL;

   851 

   852         {

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

   854             symbol_c *IN_param_value = &this->default_variable_name;

   855         

   856             symbol_c *IN_type_symbol = param_data_type;

   857             last_type_symbol = param_data_type;

   858             

   859             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   860             {

   861         

   862                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   863                 s4o.print("(");

   864                 return_type_symbol->accept(*this);

   865                 s4o.print(")");

   866                 IN_param_value->accept(*this);

   867                 return NULL;

   868                 

   869             }

   870             

   871             ERROR;

   872         }

   873         

   874     }/*function_sint_to_ulint*/

   875     break;

   876 

   877 /****

   878  *SINT_TO_REAL

   879  */

   880     case function_sint_to_real :

   881     {

   882         symbol_c *last_type_symbol = NULL;

   883 

   884         {

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

   886             symbol_c *IN_param_value = &this->default_variable_name;

   887         

   888             symbol_c *IN_type_symbol = param_data_type;

   889             last_type_symbol = param_data_type;

   890             

   891             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   892             {

   893         

   894                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   895                 s4o.print("(");

   896                 return_type_symbol->accept(*this);

   897                 s4o.print(")");

   898                 IN_param_value->accept(*this);

   899                 return NULL;

   900                 

   901             }

   902             

   903             ERROR;

   904         }

   905         

   906     }/*function_sint_to_real*/

   907     break;

   908 

   909 /****

   910  *SINT_TO_LREAL

   911  */

   912     case function_sint_to_lreal :

   913     {

   914         symbol_c *last_type_symbol = NULL;

   915 

   916         {

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

   918             symbol_c *IN_param_value = &this->default_variable_name;

   919         

   920             symbol_c *IN_type_symbol = param_data_type;

   921             last_type_symbol = param_data_type;

   922             

   923             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   924             {

   925         

   926                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   927                 s4o.print("(");

   928                 return_type_symbol->accept(*this);

   929                 s4o.print(")");

   930                 IN_param_value->accept(*this);

   931                 return NULL;

   932                 

   933             }

   934             

   935             ERROR;

   936         }

   937         

   938     }/*function_sint_to_lreal*/

   939     break;

   940 

   941 /****

   942  *SINT_TO_TIME

   943  */

   944     case function_sint_to_time :

   945     {

   946         symbol_c *last_type_symbol = NULL;

   947 

   948         {

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

   950             symbol_c *IN_param_value = &this->default_variable_name;

   951         

   952             symbol_c *IN_type_symbol = param_data_type;

   953             last_type_symbol = param_data_type;

   954             

   955             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   956             {

   957         

   958                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   959                 s4o.print("(");

   960                 return_type_symbol->accept(*this);

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

   962                 IN_param_value->accept(*this);

   963                 s4o.print(")");

   964                 return NULL;

   965                 

   966             }

   967             

   968             ERROR;

   969         }

   970         

   971     }/*function_sint_to_time*/

   972     break;

   973 

   974 /****

   975  *SINT_TO_DATE

   976  */

   977     case function_sint_to_date :

   978     {

   979         symbol_c *last_type_symbol = NULL;

   980 

   981         {

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

   983             symbol_c *IN_param_value = &this->default_variable_name;

   984         

   985             symbol_c *IN_type_symbol = param_data_type;

   986             last_type_symbol = param_data_type;

   987             

   988             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

   989             {

   990         

   991                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   992                 s4o.print("(");

   993                 return_type_symbol->accept(*this);

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

   995                 IN_param_value->accept(*this);

   996                 s4o.print(")");

   997                 return NULL;

   998                 

   999             }

  1000             

  1001             ERROR;

  1002         }

  1003         

  1004     }/*function_sint_to_date*/

  1005     break;

  1006 

  1007 /****

  1008  *SINT_TO_TOD

  1009  */

  1010     case function_sint_to_tod :

  1011     {

  1012         symbol_c *last_type_symbol = NULL;

  1013 

  1014         {

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

  1016             symbol_c *IN_param_value = &this->default_variable_name;

  1017         

  1018             symbol_c *IN_type_symbol = param_data_type;

  1019             last_type_symbol = param_data_type;

  1020             

  1021             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

  1022             {

  1023         

  1024                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

  1025                 s4o.print("(");

  1026                 return_type_symbol->accept(*this);

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

  1028                 IN_param_value->accept(*this);

  1029                 s4o.print(")");

  1030                 return NULL;

  1031                 

  1032             }

  1033             

  1034             ERROR;

  1035         }

  1036         

  1037     }/*function_sint_to_tod*/

  1038     break;

  1039 

  1040 /****

  1041  *SINT_TO_DT

  1042  */

  1043     case function_sint_to_dt :

  1044     {

  1045         symbol_c *last_type_symbol = NULL;

  1046 

  1047         {

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

  1049             symbol_c *IN_param_value = &this->default_variable_name;

  1050         

  1051             symbol_c *IN_type_symbol = param_data_type;

  1052             last_type_symbol = param_data_type;

  1053             

  1054             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

  1055             {

  1056         

  1057                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

  1058                 s4o.print("(");

  1059                 return_type_symbol->accept(*this);

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

  1061                 IN_param_value->accept(*this);

  1062                 s4o.print(")");

  1063                 return NULL;

  1064                 

  1065             }

  1066             

  1067             ERROR;

  1068         }

  1069         

  1070     }/*function_sint_to_dt*/

  1071     break;

  1072 

  1073 /****

  1074  *SINT_TO_STRING

  1075  */

  1076     case function_sint_to_string :

  1077     {

  1078         symbol_c *last_type_symbol = NULL;

  1079 

  1080         {

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

  1082             symbol_c *IN_param_value = &this->default_variable_name;

  1083         

  1084             symbol_c *IN_type_symbol = param_data_type;

  1085             last_type_symbol = param_data_type;

  1086             

  1087             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

  1088             {

  1089         

  1090                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

  1091                 s4o.print("(");

  1092                 return_type_symbol->accept(*this);

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

  1094                 IN_param_value->accept(*this);

  1095                 s4o.print(")");

  1096                 return NULL;

  1097                 

  1098             }

  1099             

  1100             ERROR;

  1101         }

  1102         

  1103     }/*function_sint_to_string*/

  1104     break;

  1105 

  1106 /****

  1107  *SINT_TO_BYTE

  1108  */

  1109     case function_sint_to_byte :

  1110     {

  1111         symbol_c *last_type_symbol = NULL;

  1112 

  1113         {

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

  1115             symbol_c *IN_param_value = &this->default_variable_name;

  1116         

  1117             symbol_c *IN_type_symbol = param_data_type;

  1118             last_type_symbol = param_data_type;

  1119             

  1120             if (typeid(*last_type_symbol) == typeid(sint_type_name_c))

  1121             {

  1122         

  1123                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

  1124                 s4o.print("(");

  1125                 return_type_symbol->accept(*this);

  1126                 s4o.print(")");

  1127                 IN_param_value->accept(*this);

  1128                 return NULL;

  1129                 

  1130             }

  1131             

  1132             ERROR;

  1133         }

  1134         

  1135     }/*function_sint_to_byte*/

  1136     break;

  1137 

  1138 /****