9  *BOOL_TO_SINT

    10  */

    11     case function_bool_to_sint :

    12     {

    13         symbol_c *last_type_symbol = NULL;

    14 

    15         {

    16             identifier_c param_name("IN");

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

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

    19             

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

    21             if (IN_param_value == NULL)

    22               IN_param_value = function_call_param_iterator.next();

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

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

    25             

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

    27             {

    28         

    29                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    30                 s4o.print("(");

    31                 return_type_symbol->accept(*this);

    32                 s4o.print(")");

    33                 IN_param_value->accept(*this);

    34                 return NULL;

    35                 

    36             }

    37             

    38             ERROR;

    39         }

    40         

    41     }/*function_bool_to_sint*/

    42     break;

    43 

    44 /****

    45  *BOOL_TO_INT

    46  */

    47     case function_bool_to_int :

    48     {

    49         symbol_c *last_type_symbol = NULL;

    50 

    51         {

    52             identifier_c param_name("IN");

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

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

    55             

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

    57             if (IN_param_value == NULL)

    58               IN_param_value = function_call_param_iterator.next();

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

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

    61             

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

    63             {

    64         

    65                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    66                 s4o.print("(");

    67                 return_type_symbol->accept(*this);

    68                 s4o.print(")");

    69                 IN_param_value->accept(*this);

    70                 return NULL;

    71                 

    72             }

    73             

    74             ERROR;

    75         }

    76         

    77     }/*function_bool_to_int*/

    78     break;

    79 

    80 /****

    81  *BOOL_TO_DINT

    82  */

    83     case function_bool_to_dint :

    84     {

    85         symbol_c *last_type_symbol = NULL;

    86 

    87         {

    88             identifier_c param_name("IN");

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

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

    91             

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

    93             if (IN_param_value == NULL)

    94               IN_param_value = function_call_param_iterator.next();

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

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

    97             

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

    99             {

   100         

   101                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   102                 s4o.print("(");

   103                 return_type_symbol->accept(*this);

   104                 s4o.print(")");

   105                 IN_param_value->accept(*this);

   106                 return NULL;

   107                 

   108             }

   109             

   110             ERROR;

   111         }

   112         

   113     }/*function_bool_to_dint*/

   114     break;

   115 

   116 /****

   117  *BOOL_TO_LINT

   118  */

   119     case function_bool_to_lint :

   120     {

   121         symbol_c *last_type_symbol = NULL;

   122 

   123         {

   124             identifier_c param_name("IN");

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

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

   127             

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

   129             if (IN_param_value == NULL)

   130               IN_param_value = function_call_param_iterator.next();

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

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

   133             

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

   135             {

   136         

   137                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   138                 s4o.print("(");

   139                 return_type_symbol->accept(*this);

   140                 s4o.print(")");

   141                 IN_param_value->accept(*this);

   142                 return NULL;

   143                 

   144             }

   145             

   146             ERROR;

   147         }

   148         

   149     }/*function_bool_to_lint*/

   150     break;

   151 

   152 /****

   153  *BOOL_TO_USINT

   154  */

   155     case function_bool_to_usint :

   156     {

   157         symbol_c *last_type_symbol = NULL;

   158 

   159         {

   160             identifier_c param_name("IN");

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

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

   163             

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

   165             if (IN_param_value == NULL)

   166               IN_param_value = function_call_param_iterator.next();

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

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

   169             

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

   171             {

   172         

   173                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   174                 s4o.print("(");

   175                 return_type_symbol->accept(*this);

   176                 s4o.print(")");

   177                 IN_param_value->accept(*this);

   178                 return NULL;

   179                 

   180             }

   181             

   182             ERROR;

   183         }

   184         

   185     }/*function_bool_to_usint*/

   186     break;

   187 

   188 /****

   189  *BOOL_TO_UINT

   190  */

   191     case function_bool_to_uint :

   192     {

   193         symbol_c *last_type_symbol = NULL;

   194 

   195         {

   196             identifier_c param_name("IN");

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

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

   199             

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

   201             if (IN_param_value == NULL)

   202               IN_param_value = function_call_param_iterator.next();

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

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

   205             

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

   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             identifier_c param_name("IN");

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

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

   235             

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

   237             if (IN_param_value == NULL)

   238               IN_param_value = function_call_param_iterator.next();

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

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

   241             

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

   243             {

   244         

   245                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   246                 s4o.print("(");

   247                 return_type_symbol->accept(*this);

   248                 s4o.print(")");

   249                 IN_param_value->accept(*this);

   250                 return NULL;

   251                 

   252             }

   253             

   254             ERROR;

   255         }

   256         

   257     }/*function_bool_to_udint*/

   258     break;

   259 

   260 /****

   261  *BOOL_TO_ULINT

   262  */

   263     case function_bool_to_ulint :

   264     {

   265         symbol_c *last_type_symbol = NULL;

   266 

   267         {

   268             identifier_c param_name("IN");

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

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

   271             

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

   273             if (IN_param_value == NULL)

   274               IN_param_value = function_call_param_iterator.next();

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

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

   277             

   278             if (typeid(*last_type_symbol) == typeid(bool_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_bool_to_ulint*/

   294     break;

   295 

   296 /****

   297  *BOOL_TO_REAL

   298  */

   299     case function_bool_to_real :

   300     {

   301         symbol_c *last_type_symbol = NULL;

   302 

   303         {

   304             identifier_c param_name("IN");

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

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

   307             

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

   309             if (IN_param_value == NULL)

   310               IN_param_value = function_call_param_iterator.next();

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

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

   313             

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

   315             {

   316         

   317                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   318                 s4o.print("(");

   319                 return_type_symbol->accept(*this);

   320                 s4o.print(")");

   321                 IN_param_value->accept(*this);

   322                 return NULL;

   323                 

   324             }

   325             

   326             ERROR;

   327         }

   328         

   329     }/*function_bool_to_real*/

   330     break;

   331 

   332 /****

   333  *BOOL_TO_LREAL

   334  */

   335     case function_bool_to_lreal :

   336     {

   337         symbol_c *last_type_symbol = NULL;

   338 

   339         {

   340             identifier_c param_name("IN");

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

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

   343             

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

   345             if (IN_param_value == NULL)

   346               IN_param_value = function_call_param_iterator.next();

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

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

   349             

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

   351             {

   352         

   353                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   354                 s4o.print("(");

   355                 return_type_symbol->accept(*this);

   356                 s4o.print(")");

   357                 IN_param_value->accept(*this);

   358                 return NULL;

   359                 

   360             }

   361             

   362             ERROR;

   363         }

   364         

   365     }/*function_bool_to_lreal*/

   366     break;

   367 

   368 /****

   369  *BOOL_TO_TIME

   370  */

   371     case function_bool_to_time :

   372     {

   373         symbol_c *last_type_symbol = NULL;

   374 

   375         {

   376             identifier_c param_name("IN");

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

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

   379             

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

   381             if (IN_param_value == NULL)

   382               IN_param_value = function_call_param_iterator.next();

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

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

   385             

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

   387             {

   388         

   389                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   390                 s4o.print("(");

   391                 return_type_symbol->accept(*this);

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

   393                 IN_param_value->accept(*this);

   394                 s4o.print(")");

   395                 return NULL;

   396                 

   397             }

   398             

   399             ERROR;

   400         }

   401         

   402     }/*function_bool_to_time*/

   403     break;

   404 

   405 /****

   406  *BOOL_TO_DATE

   407  */

   408     case function_bool_to_date :

   409     {

   410         symbol_c *last_type_symbol = NULL;

   411 

   412         {

   413             identifier_c param_name("IN");

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

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

   416             

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

   418             if (IN_param_value == NULL)

   419               IN_param_value = function_call_param_iterator.next();

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

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

   422             

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

   424             {

   425         

   426                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   427                 s4o.print("(");

   428                 return_type_symbol->accept(*this);

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

   430                 IN_param_value->accept(*this);

   431                 s4o.print(")");

   432                 return NULL;

   433                 

   434             }

   435             

   436             ERROR;

   437         }

   438         

   439     }/*function_bool_to_date*/

   440     break;

   441 

   442 /****

   443  *BOOL_TO_TOD

   444  */

   445     case function_bool_to_tod :

   446     {

   447         symbol_c *last_type_symbol = NULL;

   448 

   449         {

   450             identifier_c param_name("IN");

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

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

   453             

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

   455             if (IN_param_value == NULL)

   456               IN_param_value = function_call_param_iterator.next();

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

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

   459             

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

   461             {

   462         

   463                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   464                 s4o.print("(");

   465                 return_type_symbol->accept(*this);

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

   467                 IN_param_value->accept(*this);

   468                 s4o.print(")");

   469                 return NULL;

   470                 

   471             }

   472             

   473             ERROR;

   474         }

   475         

   476     }/*function_bool_to_tod*/

   477     break;

   478 

   479 /****

   480  *BOOL_TO_DT

   481  */

   482     case function_bool_to_dt :

   483     {

   484         symbol_c *last_type_symbol = NULL;

   485 

   486         {

   487             identifier_c param_name("IN");

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

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

   490             

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

   492             if (IN_param_value == NULL)

   493               IN_param_value = function_call_param_iterator.next();

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

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

   496             

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

   498             {

   499         

   500                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   501                 s4o.print("(");

   502                 return_type_symbol->accept(*this);

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

   504                 IN_param_value->accept(*this);

   505                 s4o.print(")");

   506                 return NULL;

   507                 

   508             }

   509             

   510             ERROR;

   511         }

   512         

   513     }/*function_bool_to_dt*/

   514     break;

   515 

   516 /****

   517  *BOOL_TO_STRING

   518  */

   519     case function_bool_to_string :

   520     {

   521         symbol_c *last_type_symbol = NULL;

   522 

   523         {

   524             identifier_c param_name("IN");

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

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

   527             

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

   529             if (IN_param_value == NULL)

   530               IN_param_value = function_call_param_iterator.next();

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

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

   533             

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

   535             {

   536         

   537                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   538                 s4o.print("(");

   539                 return_type_symbol->accept(*this);

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

   541                 IN_param_value->accept(*this);

   542                 s4o.print(")");

   543                 return NULL;

   544                 

   545             }

   546             

   547             ERROR;

   548         }

   549         

   550     }/*function_bool_to_string*/

   551     break;

   552 

   553 /****

   554  *BOOL_TO_BYTE

   555  */

   556     case function_bool_to_byte :

   557     {

   558         symbol_c *last_type_symbol = NULL;

   559 

   560         {

   561             identifier_c param_name("IN");

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

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

   564             

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

   566             if (IN_param_value == NULL)

   567               IN_param_value = function_call_param_iterator.next();

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

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

   570             

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

   572             {

   573         

   574                 symbol_c * return_type_symbol = &search_constant_type_c::byte_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_byte*/

   587     break;

   588 

   589 /****

   590  *BOOL_TO_WORD

   591  */

   592     case function_bool_to_word :

   593     {

   594         symbol_c *last_type_symbol = NULL;

   595 

   596         {

   597             identifier_c param_name("IN");

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

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

   600             

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

   602             if (IN_param_value == NULL)

   603               IN_param_value = function_call_param_iterator.next();

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

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

   606             

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

   608             {

   609         

   610                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   611                 s4o.print("(");

   612                 return_type_symbol->accept(*this);

   613                 s4o.print(")");

   614                 IN_param_value->accept(*this);

   615                 return NULL;

   616                 

   617             }

   618             

   619             ERROR;

   620         }

   621         

   622     }/*function_bool_to_word*/

   623     break;

   624 

   625 /****

   626  *BOOL_TO_DWORD

   627  */

   628     case function_bool_to_dword :

   629     {

   630         symbol_c *last_type_symbol = NULL;

   631 

   632         {

   633             identifier_c param_name("IN");

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

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

   636             

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

   638             if (IN_param_value == NULL)

   639               IN_param_value = function_call_param_iterator.next();

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

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

   642             

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

   644             {

   645         

   646                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   647                 s4o.print("(");

   648                 return_type_symbol->accept(*this);

   649                 s4o.print(")");

   650                 IN_param_value->accept(*this);

   651                 return NULL;

   652                 

   653             }

   654             

   655             ERROR;

   656         }

   657         

   658     }/*function_bool_to_dword*/

   659     break;

   660 

   661 /****

   662  *BOOL_TO_LWORD

   663  */

   664     case function_bool_to_lword :

   665     {

   666         symbol_c *last_type_symbol = NULL;

   667 

   668         {

   669             identifier_c param_name("IN");

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

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

   672             

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

   674             if (IN_param_value == NULL)

   675               IN_param_value = function_call_param_iterator.next();

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

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

   678             

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

   680             {

   681         

   682                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   683                 s4o.print("(");

   684                 return_type_symbol->accept(*this);

   685                 s4o.print(")");

   686                 IN_param_value->accept(*this);

   687                 return NULL;

   688                 

   689             }

   690             

   691             ERROR;

   692         }

   693         

   694     }/*function_bool_to_lword*/

   695     break;

   696 

   697 /****

   698  *SINT_TO_BOOL

   699  */

   700     case function_sint_to_bool :

   701     {

   702         symbol_c *last_type_symbol = NULL;

   703 

   704         {

   705             identifier_c param_name("IN");

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

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

   708             

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

   710             if (IN_param_value == NULL)

   711               IN_param_value = function_call_param_iterator.next();

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

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

   714             

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

   716             {

   717         

   718                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   719                 s4o.print("(");

   720                 return_type_symbol->accept(*this);

   721                 s4o.print(")");

   722                 IN_param_value->accept(*this);

   723                 return NULL;

   724                 

   725             }

   726             

   727             ERROR;

   728         }

   729         

   730     }/*function_sint_to_bool*/

   731     break;

   732 

   733 /****

   734  *SINT_TO_INT

   735  */

   736     case function_sint_to_int :

   737     {

   738         symbol_c *last_type_symbol = NULL;

   739 

   740         {

   741             identifier_c param_name("IN");

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

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

   744             

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

   746             if (IN_param_value == NULL)

   747               IN_param_value = function_call_param_iterator.next();

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

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

   750             

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

   752             {

   753         

   754                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   755                 s4o.print("(");

   756                 return_type_symbol->accept(*this);

   757                 s4o.print(")");

   758                 IN_param_value->accept(*this);

   759                 return NULL;

   760                 

   761             }

   762             

   763             ERROR;

   764         }

   765         

   766     }/*function_sint_to_int*/

   767     break;

   768 

   769 /****

   770  *SINT_TO_DINT

   771  */

   772     case function_sint_to_dint :

   773     {

   774         symbol_c *last_type_symbol = NULL;

   775 

   776         {

   777             identifier_c param_name("IN");

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

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

   780             

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

   782             if (IN_param_value == NULL)

   783               IN_param_value = function_call_param_iterator.next();

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

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

   786             

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

   788             {

   789         

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

   803     break;

   804 

   805 /****

   806  *SINT_TO_LINT

   807  */

   808     case function_sint_to_lint :

   809     {

   810         symbol_c *last_type_symbol = NULL;

   811 

   812         {

   813             identifier_c param_name("IN");

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

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

   816             

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

   818             if (IN_param_value == NULL)

   819               IN_param_value = function_call_param_iterator.next();

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

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

   822             

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

   824             {

   825         

   826                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   827                 s4o.print("(");

   828                 return_type_symbol->accept(*this);

   829                 s4o.print(")");

   830                 IN_param_value->accept(*this);

   831                 return NULL;

   832                 

   833             }

   834             

   835             ERROR;

   836         }

   837         

   838     }/*function_sint_to_lint*/

   839     break;

   840 

   841 /****

   842  *SINT_TO_USINT

   843  */

   844     case function_sint_to_usint :

   845     {

   846         symbol_c *last_type_symbol = NULL;

   847 

   848         {

   849             identifier_c param_name("IN");

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

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

   852             

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

   854             if (IN_param_value == NULL)

   855               IN_param_value = function_call_param_iterator.next();

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

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

   858             

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

   860             {

   861         

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

   875     break;

   876 

   877 /****

   878  *SINT_TO_UINT

   879  */

   880     case function_sint_to_uint :

   881     {

   882         symbol_c *last_type_symbol = NULL;

   883 

   884         {

   885             identifier_c param_name("IN");

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

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

   888             

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

   890             if (IN_param_value == NULL)

   891               IN_param_value = function_call_param_iterator.next();

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

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

   894             

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

   896             {

   897         

   898                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   899                 s4o.print("(");

   900                 return_type_symbol->accept(*this);

   901                 s4o.print(")");

   902                 IN_param_value->accept(*this);

   903                 return NULL;

   904                 

   905             }

   906             

   907             ERROR;

   908         }

   909         

   910     }/*function_sint_to_uint*/

   911     break;

   912 

   913 /****

   914  *SINT_TO_UDINT

   915  */

   916     case function_sint_to_udint :

   917     {

   918         symbol_c *last_type_symbol = NULL;

   919 

   920         {

   921             identifier_c param_name("IN");

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

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

   924             

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

   926             if (IN_param_value == NULL)

   927               IN_param_value = function_call_param_iterator.next();

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

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

   930             

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

   932             {

   933         

   934                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   935                 s4o.print("(");

   936                 return_type_symbol->accept(*this);

   937                 s4o.print(")");

   938                 IN_param_value->accept(*this);

   939                 return NULL;

   940                 

   941             }

   942             

   943             ERROR;

   944         }

   945         

   946     }/*function_sint_to_udint*/

   947     break;

   948 

   949 /****

   950  *SINT_TO_ULINT

   951  */

   952     case function_sint_to_ulint :

   953     {

   954         symbol_c *last_type_symbol = NULL;

   955 

   956         {

   957             identifier_c param_name("IN");

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

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

   960             

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

   962             if (IN_param_value == NULL)

   963               IN_param_value = function_call_param_iterator.next();

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

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

   966             

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

   968             {

   969         

   970                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   971                 s4o.print("(");

   972                 return_type_symbol->accept(*this);

   973                 s4o.print(")");

   974                 IN_param_value->accept(*this);

   975                 return NULL;

   976                 

   977             }

   978             

   979             ERROR;

   980         }

   981         

   982     }/*function_sint_to_ulint*/

   983     break;

   984 

   985 /****

   986  *SINT_TO_REAL

   987  */

   988     case function_sint_to_real :

   989     {

   990         symbol_c *last_type_symbol = NULL;

   991 

   992         {

   993             identifier_c param_name("IN");

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

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

   996             

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

   998             if (IN_param_value == NULL)

   999               IN_param_value = function_call_param_iterator.next();

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

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

  1002             

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

  1004             {

  1005         

  1006                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

  1007                 s4o.print("(");

  1008                 return_type_symbol->accept(*this);

  1009                 s4o.print(")");

  1010                 IN_param_value->accept(*this);

  1011                 return NULL;

  1012                 

  1013             }

  1014             

  1015             ERROR;

  1016         }

  1017         

  1018     }/*function_sint_to_real*/

  1019     break;

  1020 

  1021 /****

  1022  *SINT_TO_LREAL

  1023  */

  1024     case function_sint_to_lreal :

  1025     {

  1026         symbol_c *last_type_symbol = NULL;

  1027 

  1028         {

  1029             identifier_c param_name("IN");

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

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

  1032             

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

  1034             if (IN_param_value == NULL)

  1035               IN_param_value = function_call_param_iterator.next();

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

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

  1038             

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

  1040             {

  1041         

  1042                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

  1043                 s4o.print("(");

  1044                 return_type_symbol->accept(*this);

  1045                 s4o.print(")");

  1046                 IN_param_value->accept(*this);

  1047                 return NULL;

  1048                 

  1049             }

  1050             

  1051             ERROR;

  1052         }

  1053         

  1054     }/*function_sint_to_lreal*/

  1055     break;

  1056 

  1057 /****

  1058  *SINT_TO_TIME

  1059  */

  1060     case function_sint_to_time :

  1061     {

  1062         symbol_c *last_type_symbol = NULL;

  1063 

  1064         {

  1065             identifier_c param_name("IN");

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

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

  1068             

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

  1070             if (IN_param_value == NULL)

  1071               IN_param_value = function_call_param_iterator.next();

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

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

  1074             

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

  1076             {

  1077         

  1078                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

  1079                 s4o.print("(");

  1080                 return_type_symbol->accept(*this);

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

  1082                 IN_param_value->accept(*this);

  1083                 s4o.print(")");

  1084                 return NULL;

  1085                 

  1086             }

  1087             

  1088             ERROR;

  1089         }

  1090         

  1091     }/*function_sint_to_time*/

  1092     break;

  1093 

  1094 /****

  1095  *SINT_TO_DATE

  1096  */

  1097     case function_sint_to_date :

  1098     {

  1099         symbol_c *last_type_symbol = NULL;

  1100 

  1101         {

  1102             identifier_c param_name("IN");

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

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

  1105             

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

  1107             if (IN_param_value == NULL)

  1108               IN_param_value = function_call_param_iterator.next();

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

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

  1111             

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

  1113             {

  1114         

  1115                 symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

  1116                 s4o.print("(");

  1117                 return_type_symbol->accept(*this);

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

  1119                 IN_param_value->accept(*this);

  1120                 s4o.print(")");

  1121                 return NULL;

  1122                 

  1123             }

  1124             

  1125             ERROR;

  1126         }

  1127         

  1128     }/*function_sint_to_date*/

  1129     break;

  1130 

  1131 /****

  1132  *SINT_TO_TOD

  1133  */

  1134     case function_sint_to_tod :

  1135     {

  1136         symbol_c *last_type_symbol = NULL;

  1137 

  1138         {