1 

     2 /****

     3  * IEC 61131-3 standard function lib

     4  * generated code, do not edit by hand

     5  */

     6 switch(current_function_type){

     7 

     8 /****

     9  *REAL_TO_LREAL

    10  */

    11     case function_real_to_lreal :

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

    23             {

    24         

    25                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_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_real_to_lreal*/

    38     break;

    39 

    40 /****

    41  *REAL_TO_SINT

    42  */

    43     case function_real_to_sint :

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

    55             {

    56         

    57                 symbol_c * return_type_symbol = &search_constant_type_c::sint_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_real_to_sint*/

    70     break;

    71 

    72 /****

    73  *REAL_TO_INT

    74  */

    75     case function_real_to_int :

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

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

   102     break;

   103 

   104 /****

   105  *REAL_TO_DINT

   106  */

   107     case function_real_to_dint :

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

   119             {

   120         

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

   134     break;

   135 

   136 /****

   137  *REAL_TO_LINT

   138  */

   139     case function_real_to_lint :

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

   151             {

   152         

   153                 symbol_c * return_type_symbol = &search_constant_type_c::lint_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_real_to_lint*/

   166     break;

   167 

   168 /****

   169  *REAL_TO_USINT

   170  */

   171     case function_real_to_usint :

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

   183             {

   184         

   185                 symbol_c * return_type_symbol = &search_constant_type_c::usint_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_real_to_usint*/

   198     break;

   199 

   200 /****

   201  *REAL_TO_UINT

   202  */

   203     case function_real_to_uint :

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

   215             {

   216         

   217                 symbol_c * return_type_symbol = &search_constant_type_c::uint_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_real_to_uint*/

   230     break;

   231 

   232 /****

   233  *REAL_TO_UDINT

   234  */

   235     case function_real_to_udint :

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

   247             {

   248         

   249                 symbol_c * return_type_symbol = &search_constant_type_c::udint_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_real_to_udint*/

   262     break;

   263 

   264 /****

   265  *REAL_TO_ULINT

   266  */

   267     case function_real_to_ulint :

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

   279             {

   280         

   281                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_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_real_to_ulint*/

   294     break;

   295 

   296 /****

   297  *REAL_TO_TIME

   298  */

   299     case function_real_to_time :

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

   311             {

   312         

   313                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   314                 s4o.print("(");

   315                 return_type_symbol->accept(*this);

   316                 s4o.print(")real_to_time(");

   317                 IN_param_value->accept(*this);

   318                 s4o.print(")");

   319                 return NULL;

   320                 

   321             }

   322             

   323             ERROR;

   324         }

   325         

   326     }/*function_real_to_time*/

   327     break;

   328 

   329 /****

   330  *REAL_TO_BOOL

   331  */

   332     case function_real_to_bool :

   333     {

   334         symbol_c *last_type_symbol = NULL;

   335 

   336         {

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

   338             symbol_c *IN_param_value = &this->default_variable_name;

   339         

   340             symbol_c *IN_type_symbol = param_data_type;

   341             last_type_symbol = param_data_type;

   342             

   343             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   344             {

   345         

   346                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   347                 s4o.print("(");

   348                 return_type_symbol->accept(*this);

   349                 s4o.print(")");

   350                 IN_param_value->accept(*this);

   351                 return NULL;

   352                 

   353             }

   354             

   355             ERROR;

   356         }

   357         

   358     }/*function_real_to_bool*/

   359     break;

   360 

   361 /****

   362  *REAL_TO_BYTE

   363  */

   364     case function_real_to_byte :

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

   376             {

   377         

   378                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   379                 s4o.print("(");

   380                 return_type_symbol->accept(*this);

   381                 s4o.print(")");

   382                 IN_param_value->accept(*this);

   383                 return NULL;

   384                 

   385             }

   386             

   387             ERROR;

   388         }

   389         

   390     }/*function_real_to_byte*/

   391     break;

   392 

   393 /****

   394  *REAL_TO_WORD

   395  */

   396     case function_real_to_word :

   397     {

   398         symbol_c *last_type_symbol = NULL;

   399 

   400         {

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

   402             symbol_c *IN_param_value = &this->default_variable_name;

   403         

   404             symbol_c *IN_type_symbol = param_data_type;

   405             last_type_symbol = param_data_type;

   406             

   407             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   408             {

   409         

   410                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   411                 s4o.print("(");

   412                 return_type_symbol->accept(*this);

   413                 s4o.print(")");

   414                 IN_param_value->accept(*this);

   415                 return NULL;

   416                 

   417             }

   418             

   419             ERROR;

   420         }

   421         

   422     }/*function_real_to_word*/

   423     break;

   424 

   425 /****

   426  *REAL_TO_DWORD

   427  */

   428     case function_real_to_dword :

   429     {

   430         symbol_c *last_type_symbol = NULL;

   431 

   432         {

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

   434             symbol_c *IN_param_value = &this->default_variable_name;

   435         

   436             symbol_c *IN_type_symbol = param_data_type;

   437             last_type_symbol = param_data_type;

   438             

   439             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   440             {

   441         

   442                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   443                 s4o.print("(");

   444                 return_type_symbol->accept(*this);

   445                 s4o.print(")");

   446                 IN_param_value->accept(*this);

   447                 return NULL;

   448                 

   449             }

   450             

   451             ERROR;

   452         }

   453         

   454     }/*function_real_to_dword*/

   455     break;

   456 

   457 /****

   458  *REAL_TO_LWORD

   459  */

   460     case function_real_to_lword :

   461     {

   462         symbol_c *last_type_symbol = NULL;

   463 

   464         {

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

   466             symbol_c *IN_param_value = &this->default_variable_name;

   467         

   468             symbol_c *IN_type_symbol = param_data_type;

   469             last_type_symbol = param_data_type;

   470             

   471             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   472             {

   473         

   474                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   475                 s4o.print("(");

   476                 return_type_symbol->accept(*this);

   477                 s4o.print(")");

   478                 IN_param_value->accept(*this);

   479                 return NULL;

   480                 

   481             }

   482             

   483             ERROR;

   484         }

   485         

   486     }/*function_real_to_lword*/

   487     break;

   488 

   489 /****

   490  *REAL_TO_STRING

   491  */

   492     case function_real_to_string :

   493     {

   494         symbol_c *last_type_symbol = NULL;

   495 

   496         {

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

   498             symbol_c *IN_param_value = &this->default_variable_name;

   499         

   500             symbol_c *IN_type_symbol = param_data_type;

   501             last_type_symbol = param_data_type;

   502             

   503             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   504             {

   505         

   506                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   507                 s4o.print("(");

   508                 return_type_symbol->accept(*this);

   509                 s4o.print(")int_to_string(");

   510                 IN_param_value->accept(*this);

   511                 s4o.print(", 10)");

   512                 return NULL;

   513                 

   514             }

   515             

   516             ERROR;

   517         }

   518         

   519     }/*function_real_to_string*/

   520     break;

   521 

   522 /****

   523  *REAL_TO_WSTRING

   524  */

   525     case function_real_to_wstring :

   526     {

   527         symbol_c *last_type_symbol = NULL;

   528 

   529         {

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

   531             symbol_c *IN_param_value = &this->default_variable_name;

   532         

   533             symbol_c *IN_type_symbol = param_data_type;

   534             last_type_symbol = param_data_type;

   535             

   536             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   537             {

   538         

   539                 symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;

   540                 s4o.print("(");

   541                 return_type_symbol->accept(*this);

   542                 s4o.print(")int_to_string(");

   543                 IN_param_value->accept(*this);

   544                 s4o.print(", 10)");

   545                 return NULL;

   546                 

   547             }

   548             

   549             ERROR;

   550         }

   551         

   552     }/*function_real_to_wstring*/

   553     break;

   554 

   555 /****

   556  *REAL_TO_DATE

   557  */

   558     case function_real_to_date :

   559     {

   560         symbol_c *last_type_symbol = NULL;

   561 

   562         {

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

   564             symbol_c *IN_param_value = &this->default_variable_name;

   565         

   566             symbol_c *IN_type_symbol = param_data_type;

   567             last_type_symbol = param_data_type;

   568             

   569             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   570             {

   571         

   572                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   573                 s4o.print("(");

   574                 return_type_symbol->accept(*this);

   575                 s4o.print(")real_to_time(");

   576                 IN_param_value->accept(*this);

   577                 s4o.print(")");

   578                 return NULL;

   579                 

   580             }

   581             

   582             ERROR;

   583         }

   584         

   585     }/*function_real_to_date*/

   586     break;

   587 

   588 /****

   589  *REAL_TO_TOD

   590  */

   591     case function_real_to_tod :

   592     {

   593         symbol_c *last_type_symbol = NULL;

   594 

   595         {

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

   597             symbol_c *IN_param_value = &this->default_variable_name;

   598         

   599             symbol_c *IN_type_symbol = param_data_type;

   600             last_type_symbol = param_data_type;

   601             

   602             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   603             {

   604         

   605                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   606                 s4o.print("(");

   607                 return_type_symbol->accept(*this);

   608                 s4o.print(")real_to_time(");

   609                 IN_param_value->accept(*this);

   610                 s4o.print(")");

   611                 return NULL;

   612                 

   613             }

   614             

   615             ERROR;

   616         }

   617         

   618     }/*function_real_to_tod*/

   619     break;

   620 

   621 /****

   622  *REAL_TO_DT

   623  */

   624     case function_real_to_dt :

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

   636             {

   637         

   638                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   639                 s4o.print("(");

   640                 return_type_symbol->accept(*this);

   641                 s4o.print(")real_to_time(");

   642                 IN_param_value->accept(*this);

   643                 s4o.print(")");

   644                 return NULL;

   645                 

   646             }

   647             

   648             ERROR;

   649         }

   650         

   651     }/*function_real_to_dt*/

   652     break;

   653 

   654 /****

   655  *LREAL_TO_REAL

   656  */

   657     case function_lreal_to_real :

   658     {

   659         symbol_c *last_type_symbol = NULL;

   660 

   661         {

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

   663             symbol_c *IN_param_value = &this->default_variable_name;

   664         

   665             symbol_c *IN_type_symbol = param_data_type;

   666             last_type_symbol = param_data_type;

   667             

   668             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   669             {

   670         

   671                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   672                 s4o.print("(");

   673                 return_type_symbol->accept(*this);

   674                 s4o.print(")");

   675                 IN_param_value->accept(*this);

   676                 return NULL;

   677                 

   678             }

   679             

   680             ERROR;

   681         }

   682         

   683     }/*function_lreal_to_real*/

   684     break;

   685 

   686 /****

   687  *LREAL_TO_SINT

   688  */

   689     case function_lreal_to_sint :

   690     {

   691         symbol_c *last_type_symbol = NULL;

   692 

   693         {

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

   695             symbol_c *IN_param_value = &this->default_variable_name;

   696         

   697             symbol_c *IN_type_symbol = param_data_type;

   698             last_type_symbol = param_data_type;

   699             

   700             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   701             {

   702         

   703                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

   704                 s4o.print("(");

   705                 return_type_symbol->accept(*this);

   706                 s4o.print(")");

   707                 IN_param_value->accept(*this);

   708                 return NULL;

   709                 

   710             }

   711             

   712             ERROR;

   713         }

   714         

   715     }/*function_lreal_to_sint*/

   716     break;

   717 

   718 /****

   719  *LREAL_TO_INT

   720  */

   721     case function_lreal_to_int :

   722     {

   723         symbol_c *last_type_symbol = NULL;

   724 

   725         {

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

   727             symbol_c *IN_param_value = &this->default_variable_name;

   728         

   729             symbol_c *IN_type_symbol = param_data_type;

   730             last_type_symbol = param_data_type;

   731             

   732             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   733             {

   734         

   735                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   736                 s4o.print("(");

   737                 return_type_symbol->accept(*this);

   738                 s4o.print(")");

   739                 IN_param_value->accept(*this);

   740                 return NULL;

   741                 

   742             }

   743             

   744             ERROR;

   745         }

   746         

   747     }/*function_lreal_to_int*/

   748     break;

   749 

   750 /****

   751  *LREAL_TO_DINT

   752  */

   753     case function_lreal_to_dint :

   754     {

   755         symbol_c *last_type_symbol = NULL;

   756 

   757         {

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

   759             symbol_c *IN_param_value = &this->default_variable_name;

   760         

   761             symbol_c *IN_type_symbol = param_data_type;

   762             last_type_symbol = param_data_type;

   763             

   764             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   765             {

   766         

   767                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   768                 s4o.print("(");

   769                 return_type_symbol->accept(*this);

   770                 s4o.print(")");

   771                 IN_param_value->accept(*this);

   772                 return NULL;

   773                 

   774             }

   775             

   776             ERROR;

   777         }

   778         

   779     }/*function_lreal_to_dint*/

   780     break;

   781 

   782 /****

   783  *LREAL_TO_LINT

   784  */

   785     case function_lreal_to_lint :

   786     {

   787         symbol_c *last_type_symbol = NULL;

   788 

   789         {

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

   791             symbol_c *IN_param_value = &this->default_variable_name;

   792         

   793             symbol_c *IN_type_symbol = param_data_type;

   794             last_type_symbol = param_data_type;

   795             

   796             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   797             {

   798         

   799                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   800                 s4o.print("(");

   801                 return_type_symbol->accept(*this);

   802                 s4o.print(")");

   803                 IN_param_value->accept(*this);

   804                 return NULL;

   805                 

   806             }

   807             

   808             ERROR;

   809         }

   810         

   811     }/*function_lreal_to_lint*/

   812     break;

   813 

   814 /****

   815  *LREAL_TO_USINT

   816  */

   817     case function_lreal_to_usint :

   818     {

   819         symbol_c *last_type_symbol = NULL;

   820 

   821         {

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

   823             symbol_c *IN_param_value = &this->default_variable_name;

   824         

   825             symbol_c *IN_type_symbol = param_data_type;

   826             last_type_symbol = param_data_type;

   827             

   828             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   829             {

   830         

   831                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   832                 s4o.print("(");

   833                 return_type_symbol->accept(*this);

   834                 s4o.print(")");

   835                 IN_param_value->accept(*this);

   836                 return NULL;

   837                 

   838             }

   839             

   840             ERROR;

   841         }

   842         

   843     }/*function_lreal_to_usint*/

   844     break;

   845 

   846 /****

   847  *LREAL_TO_UINT

   848  */

   849     case function_lreal_to_uint :

   850     {

   851         symbol_c *last_type_symbol = NULL;

   852 

   853         {

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

   855             symbol_c *IN_param_value = &this->default_variable_name;

   856         

   857             symbol_c *IN_type_symbol = param_data_type;

   858             last_type_symbol = param_data_type;

   859             

   860             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   861             {

   862         

   863                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   864                 s4o.print("(");

   865                 return_type_symbol->accept(*this);

   866                 s4o.print(")");

   867                 IN_param_value->accept(*this);

   868                 return NULL;

   869                 

   870             }

   871             

   872             ERROR;

   873         }

   874         

   875     }/*function_lreal_to_uint*/

   876     break;

   877 

   878 /****

   879  *LREAL_TO_UDINT

   880  */

   881     case function_lreal_to_udint :

   882     {

   883         symbol_c *last_type_symbol = NULL;

   884 

   885         {

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

   887             symbol_c *IN_param_value = &this->default_variable_name;

   888         

   889             symbol_c *IN_type_symbol = param_data_type;

   890             last_type_symbol = param_data_type;

   891             

   892             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   893             {

   894         

   895                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   896                 s4o.print("(");

   897                 return_type_symbol->accept(*this);

   898                 s4o.print(")");

   899                 IN_param_value->accept(*this);

   900                 return NULL;

   901                 

   902             }

   903             

   904             ERROR;

   905         }

   906         

   907     }/*function_lreal_to_udint*/

   908     break;

   909 

   910 /****

   911  *LREAL_TO_ULINT

   912  */

   913     case function_lreal_to_ulint :

   914     {

   915         symbol_c *last_type_symbol = NULL;

   916 

   917         {

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

   919             symbol_c *IN_param_value = &this->default_variable_name;

   920         

   921             symbol_c *IN_type_symbol = param_data_type;

   922             last_type_symbol = param_data_type;

   923             

   924             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   925             {

   926         

   927                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   928                 s4o.print("(");

   929                 return_type_symbol->accept(*this);

   930                 s4o.print(")");

   931                 IN_param_value->accept(*this);

   932                 return NULL;

   933                 

   934             }

   935             

   936             ERROR;

   937         }

   938         

   939     }/*function_lreal_to_ulint*/

   940     break;

   941 

   942 /****

   943  *LREAL_TO_TIME

   944  */

   945     case function_lreal_to_time :

   946     {

   947         symbol_c *last_type_symbol = NULL;

   948 

   949         {

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

   951             symbol_c *IN_param_value = &this->default_variable_name;

   952         

   953             symbol_c *IN_type_symbol = param_data_type;

   954             last_type_symbol = param_data_type;

   955             

   956             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   957             {

   958         

   959                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   960                 s4o.print("(");

   961                 return_type_symbol->accept(*this);

   962                 s4o.print(")real_to_time(");

   963                 IN_param_value->accept(*this);

   964                 s4o.print(")");

   965                 return NULL;

   966                 

   967             }

   968             

   969             ERROR;

   970         }

   971         

   972     }/*function_lreal_to_time*/

   973     break;

   974 

   975 /****

   976  *LREAL_TO_BOOL

   977  */

   978     case function_lreal_to_bool :

   979     {

   980         symbol_c *last_type_symbol = NULL;

   981 

   982         {

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

   984             symbol_c *IN_param_value = &this->default_variable_name;

   985         

   986             symbol_c *IN_type_symbol = param_data_type;

   987             last_type_symbol = param_data_type;

   988             

   989             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   990             {

   991         

   992                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   993                 s4o.print("(");

   994                 return_type_symbol->accept(*this);

   995                 s4o.print(")");

   996                 IN_param_value->accept(*this);

   997                 return NULL;

   998                 

   999             }

  1000             

  1001             ERROR;

  1002         }

  1003         

  1004     }/*function_lreal_to_bool*/

  1005     break;

  1006 

  1007 /****

  1008  *LREAL_TO_BYTE

  1009  */

  1010     case function_lreal_to_byte :

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

  1022             {

  1023         

  1024                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

  1025                 s4o.print("(");

  1026                 return_type_symbol->accept(*this);

  1027                 s4o.print(")");

  1028                 IN_param_value->accept(*this);

  1029                 return NULL;

  1030                 

  1031             }

  1032             

  1033             ERROR;

  1034         }

  1035         

  1036     }/*function_lreal_to_byte*/

  1037     break;

  1038 

  1039 /****

  1040  *LREAL_TO_WORD

  1041  */

  1042     case function_lreal_to_word :

  1043     {

  1044         symbol_c *last_type_symbol = NULL;

  1045 

  1046         {

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

  1048             symbol_c *IN_param_value = &this->default_variable_name;

  1049         

  1050             symbol_c *IN_type_symbol = param_data_type;

  1051             last_type_symbol = param_data_type;

  1052             

  1053             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1054             {

  1055         

  1056                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

  1057                 s4o.print("(");

  1058                 return_type_symbol->accept(*this);

  1059                 s4o.print(")");

  1060                 IN_param_value->accept(*this);

  1061                 return NULL;

  1062                 

  1063             }

  1064             

  1065             ERROR;

  1066         }

  1067         

  1068     }/*function_lreal_to_word*/

  1069     break;

  1070 

  1071 /****

  1072  *LREAL_TO_DWORD

  1073  */

  1074     case function_lreal_to_dword :

  1075     {

  1076         symbol_c *last_type_symbol = NULL;

  1077 

  1078         {

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

  1080             symbol_c *IN_param_value = &this->default_variable_name;

  1081         

  1082             symbol_c *IN_type_symbol = param_data_type;

  1083             last_type_symbol = param_data_type;

  1084             

  1085             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1086             {

  1087         

  1088                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

  1089                 s4o.print("(");

  1090                 return_type_symbol->accept(*this);

  1091                 s4o.print(")");

  1092                 IN_param_value->accept(*this);

  1093                 return NULL;

  1094                 

  1095             }

  1096             

  1097             ERROR;

  1098         }

  1099         

  1100     }/*function_lreal_to_dword*/

  1101     break;

  1102 

  1103 /****

  1104  *LREAL_TO_LWORD

  1105  */

  1106     case function_lreal_to_lword :

  1107     {

  1108         symbol_c *last_type_symbol = NULL;

  1109 

  1110         {

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

  1112             symbol_c *IN_param_value = &this->default_variable_name;

  1113         

  1114             symbol_c *IN_type_symbol = param_data_type;

  1115             last_type_symbol = param_data_type;

  1116             

  1117             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1118             {

  1119         

  1120                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

  1121                 s4o.print("(");

  1122                 return_type_symbol->accept(*this);

  1123                 s4o.print(")");

  1124                 IN_param_value->accept(*this);

  1125                 return NULL;

  1126                 

  1127             }

  1128             

  1129             ERROR;

  1130         }

  1131         

  1132     }/*function_lreal_to_lword*/

  1133     break;

  1134 

  1135 /****

  1136  *LREAL_TO_STRING