stage4/generate_c/st_code_gen.c
author Mario de Sousa <msousa@fe.up.pt>
Wed, 30 Mar 2011 19:53:32 +0100
changeset 257 90782e241346
parent 169 bea932bc60b0
child 199 b075f28ec081
permissions -rwxr-xr-x
Huge change.
/*
 * (c) 2008 Edouard TISSERANT
 *
 * Offered to the public under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details.
 *
 * This code is made available on the understanding that it will not be
 * used in safety-critical situations without a full and competent review.
 */

/*
 * An IEC 61131-3 IL and ST compiler.
 *
 * Based on the
 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)
 *
 */

/****
 * IEC 61131-3 standard function library
 * generated code, do not edit by hand
 */
 
 
switch(current_function_type){

/****
 *REAL_TO_SINT
 */
    case function_real_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_sint*/
    break;

/****
 *REAL_TO_LINT
 */
    case function_real_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_lint*/
    break;

/****
 *REAL_TO_DINT
 */
    case function_real_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_dint*/
    break;

/****
 *REAL_TO_DATE
 */
    case function_real_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_date*/
    break;

/****
 *REAL_TO_DWORD
 */
    case function_real_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_dword*/
    break;

/****
 *REAL_TO_DT
 */
    case function_real_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_dt*/
    break;

/****
 *REAL_TO_TOD
 */
    case function_real_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_tod*/
    break;

/****
 *REAL_TO_UDINT
 */
    case function_real_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_udint*/
    break;

/****
 *REAL_TO_WORD
 */
    case function_real_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_word*/
    break;

/****
 *REAL_TO_STRING
 */
    case function_real_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_string*/
    break;

/****
 *REAL_TO_LWORD
 */
    case function_real_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_lword*/
    break;

/****
 *REAL_TO_UINT
 */
    case function_real_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_uint*/
    break;

/****
 *REAL_TO_LREAL
 */
    case function_real_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_lreal*/
    break;

/****
 *REAL_TO_BYTE
 */
    case function_real_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_byte*/
    break;

/****
 *REAL_TO_USINT
 */
    case function_real_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_usint*/
    break;

/****
 *REAL_TO_ULINT
 */
    case function_real_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_ulint*/
    break;

/****
 *REAL_TO_BOOL
 */
    case function_real_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_bool*/
    break;

/****
 *REAL_TO_TIME
 */
    case function_real_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_time*/
    break;

/****
 *REAL_TO_INT
 */
    case function_real_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_real_to_int*/
    break;

/****
 *SINT_TO_REAL
 */
    case function_sint_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_real*/
    break;

/****
 *SINT_TO_LINT
 */
    case function_sint_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_lint*/
    break;

/****
 *SINT_TO_DINT
 */
    case function_sint_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_dint*/
    break;

/****
 *SINT_TO_DATE
 */
    case function_sint_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_date*/
    break;

/****
 *SINT_TO_DWORD
 */
    case function_sint_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_dword*/
    break;

/****
 *SINT_TO_DT
 */
    case function_sint_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_dt*/
    break;

/****
 *SINT_TO_TOD
 */
    case function_sint_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_tod*/
    break;

/****
 *SINT_TO_UDINT
 */
    case function_sint_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_udint*/
    break;

/****
 *SINT_TO_WORD
 */
    case function_sint_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_word*/
    break;

/****
 *SINT_TO_STRING
 */
    case function_sint_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__sint_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_string*/
    break;

/****
 *SINT_TO_LWORD
 */
    case function_sint_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_lword*/
    break;

/****
 *SINT_TO_UINT
 */
    case function_sint_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_uint*/
    break;

/****
 *SINT_TO_LREAL
 */
    case function_sint_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_lreal*/
    break;

/****
 *SINT_TO_BYTE
 */
    case function_sint_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_byte*/
    break;

/****
 *SINT_TO_USINT
 */
    case function_sint_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_usint*/
    break;

/****
 *SINT_TO_ULINT
 */
    case function_sint_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_ulint*/
    break;

/****
 *SINT_TO_BOOL
 */
    case function_sint_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_bool*/
    break;

/****
 *SINT_TO_TIME
 */
    case function_sint_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_time*/
    break;

/****
 *SINT_TO_INT
 */
    case function_sint_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_sint_to_int*/
    break;

/****
 *LINT_TO_REAL
 */
    case function_lint_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_real*/
    break;

/****
 *LINT_TO_SINT
 */
    case function_lint_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_sint*/
    break;

/****
 *LINT_TO_DINT
 */
    case function_lint_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_dint*/
    break;

/****
 *LINT_TO_DATE
 */
    case function_lint_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_date*/
    break;

/****
 *LINT_TO_DWORD
 */
    case function_lint_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_dword*/
    break;

/****
 *LINT_TO_DT
 */
    case function_lint_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_dt*/
    break;

/****
 *LINT_TO_TOD
 */
    case function_lint_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_tod*/
    break;

/****
 *LINT_TO_UDINT
 */
    case function_lint_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_udint*/
    break;

/****
 *LINT_TO_WORD
 */
    case function_lint_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_word*/
    break;

/****
 *LINT_TO_STRING
 */
    case function_lint_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__sint_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_string*/
    break;

/****
 *LINT_TO_LWORD
 */
    case function_lint_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_lword*/
    break;

/****
 *LINT_TO_UINT
 */
    case function_lint_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_uint*/
    break;

/****
 *LINT_TO_LREAL
 */
    case function_lint_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_lreal*/
    break;

/****
 *LINT_TO_BYTE
 */
    case function_lint_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_byte*/
    break;

/****
 *LINT_TO_USINT
 */
    case function_lint_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_usint*/
    break;

/****
 *LINT_TO_ULINT
 */
    case function_lint_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_ulint*/
    break;

/****
 *LINT_TO_BOOL
 */
    case function_lint_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_bool*/
    break;

/****
 *LINT_TO_TIME
 */
    case function_lint_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_time*/
    break;

/****
 *LINT_TO_INT
 */
    case function_lint_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lint_to_int*/
    break;

/****
 *DINT_TO_REAL
 */
    case function_dint_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_real*/
    break;

/****
 *DINT_TO_SINT
 */
    case function_dint_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_sint*/
    break;

/****
 *DINT_TO_LINT
 */
    case function_dint_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_lint*/
    break;

/****
 *DINT_TO_DATE
 */
    case function_dint_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_date*/
    break;

/****
 *DINT_TO_DWORD
 */
    case function_dint_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_dword*/
    break;

/****
 *DINT_TO_DT
 */
    case function_dint_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_dt*/
    break;

/****
 *DINT_TO_TOD
 */
    case function_dint_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_tod*/
    break;

/****
 *DINT_TO_UDINT
 */
    case function_dint_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_udint*/
    break;

/****
 *DINT_TO_WORD
 */
    case function_dint_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_word*/
    break;

/****
 *DINT_TO_STRING
 */
    case function_dint_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__sint_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_string*/
    break;

/****
 *DINT_TO_LWORD
 */
    case function_dint_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_lword*/
    break;

/****
 *DINT_TO_UINT
 */
    case function_dint_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_uint*/
    break;

/****
 *DINT_TO_LREAL
 */
    case function_dint_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_lreal*/
    break;

/****
 *DINT_TO_BYTE
 */
    case function_dint_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_byte*/
    break;

/****
 *DINT_TO_USINT
 */
    case function_dint_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_usint*/
    break;

/****
 *DINT_TO_ULINT
 */
    case function_dint_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_ulint*/
    break;

/****
 *DINT_TO_BOOL
 */
    case function_dint_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_bool*/
    break;

/****
 *DINT_TO_TIME
 */
    case function_dint_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_time*/
    break;

/****
 *DINT_TO_INT
 */
    case function_dint_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dint_to_int*/
    break;

/****
 *DATE_TO_REAL
 */
    case function_date_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_real"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_real*/
    break;

/****
 *DATE_TO_SINT
 */
    case function_date_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_sint*/
    break;

/****
 *DATE_TO_LINT
 */
    case function_date_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_lint*/
    break;

/****
 *DATE_TO_DINT
 */
    case function_date_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_dint*/
    break;

/****
 *DATE_TO_DWORD
 */
    case function_date_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_dword*/
    break;

/****
 *DATE_TO_UDINT
 */
    case function_date_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_udint*/
    break;

/****
 *DATE_TO_WORD
 */
    case function_date_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_word*/
    break;

/****
 *DATE_TO_STRING
 */
    case function_date_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__date_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_string*/
    break;

/****
 *DATE_TO_LWORD
 */
    case function_date_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_lword*/
    break;

/****
 *DATE_TO_UINT
 */
    case function_date_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_uint*/
    break;

/****
 *DATE_TO_LREAL
 */
    case function_date_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_real"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_lreal*/
    break;

/****
 *DATE_TO_BYTE
 */
    case function_date_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_byte*/
    break;

/****
 *DATE_TO_USINT
 */
    case function_date_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_usint*/
    break;

/****
 *DATE_TO_ULINT
 */
    case function_date_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_ulint*/
    break;

/****
 *DATE_TO_INT
 */
    case function_date_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_date_to_int*/
    break;

/****
 *DWORD_TO_REAL
 */
    case function_dword_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_real*/
    break;

/****
 *DWORD_TO_SINT
 */
    case function_dword_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_sint*/
    break;

/****
 *DWORD_TO_LINT
 */
    case function_dword_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_lint*/
    break;

/****
 *DWORD_TO_DINT
 */
    case function_dword_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_dint*/
    break;

/****
 *DWORD_TO_DATE
 */
    case function_dword_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_date*/
    break;

/****
 *DWORD_TO_DT
 */
    case function_dword_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_dt*/
    break;

/****
 *DWORD_TO_TOD
 */
    case function_dword_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_tod*/
    break;

/****
 *DWORD_TO_UDINT
 */
    case function_dword_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_udint*/
    break;

/****
 *DWORD_TO_WORD
 */
    case function_dword_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_word*/
    break;

/****
 *DWORD_TO_STRING
 */
    case function_dword_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__bit_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_string*/
    break;

/****
 *DWORD_TO_LWORD
 */
    case function_dword_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_lword*/
    break;

/****
 *DWORD_TO_UINT
 */
    case function_dword_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_uint*/
    break;

/****
 *DWORD_TO_LREAL
 */
    case function_dword_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_lreal*/
    break;

/****
 *DWORD_TO_BYTE
 */
    case function_dword_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_byte*/
    break;

/****
 *DWORD_TO_USINT
 */
    case function_dword_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_usint*/
    break;

/****
 *DWORD_TO_ULINT
 */
    case function_dword_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_ulint*/
    break;

/****
 *DWORD_TO_BOOL
 */
    case function_dword_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_bool*/
    break;

/****
 *DWORD_TO_TIME
 */
    case function_dword_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_time*/
    break;

/****
 *DWORD_TO_INT
 */
    case function_dword_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dword_to_int*/
    break;

/****
 *DT_TO_REAL
 */
    case function_dt_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_real"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_real*/
    break;

/****
 *DT_TO_SINT
 */
    case function_dt_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_sint*/
    break;

/****
 *DT_TO_LINT
 */
    case function_dt_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_lint*/
    break;

/****
 *DT_TO_DINT
 */
    case function_dt_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_dint*/
    break;

/****
 *DT_TO_DWORD
 */
    case function_dt_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_dword*/
    break;

/****
 *DT_TO_UDINT
 */
    case function_dt_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_udint*/
    break;

/****
 *DT_TO_WORD
 */
    case function_dt_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_word*/
    break;

/****
 *DT_TO_STRING
 */
    case function_dt_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__dt_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_string*/
    break;

/****
 *DT_TO_LWORD
 */
    case function_dt_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_lword*/
    break;

/****
 *DT_TO_UINT
 */
    case function_dt_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_uint*/
    break;

/****
 *DT_TO_LREAL
 */
    case function_dt_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_real"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_lreal*/
    break;

/****
 *DT_TO_BYTE
 */
    case function_dt_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_byte*/
    break;

/****
 *DT_TO_USINT
 */
    case function_dt_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_usint*/
    break;

/****
 *DT_TO_ULINT
 */
    case function_dt_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_ulint*/
    break;

/****
 *DT_TO_INT
 */
    case function_dt_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_dt_to_int*/
    break;

/****
 *TOD_TO_REAL
 */
    case function_tod_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_real"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_real*/
    break;

/****
 *TOD_TO_SINT
 */
    case function_tod_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_sint*/
    break;

/****
 *TOD_TO_LINT
 */
    case function_tod_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_lint*/
    break;

/****
 *TOD_TO_DINT
 */
    case function_tod_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_dint*/
    break;

/****
 *TOD_TO_DWORD
 */
    case function_tod_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_dword*/
    break;

/****
 *TOD_TO_UDINT
 */
    case function_tod_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_udint*/
    break;

/****
 *TOD_TO_WORD
 */
    case function_tod_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_word*/
    break;

/****
 *TOD_TO_STRING
 */
    case function_tod_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__tod_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_string*/
    break;

/****
 *TOD_TO_LWORD
 */
    case function_tod_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_lword*/
    break;

/****
 *TOD_TO_UINT
 */
    case function_tod_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_uint*/
    break;

/****
 *TOD_TO_LREAL
 */
    case function_tod_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_real"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_lreal*/
    break;

/****
 *TOD_TO_BYTE
 */
    case function_tod_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_byte*/
    break;

/****
 *TOD_TO_USINT
 */
    case function_tod_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_usint*/
    break;

/****
 *TOD_TO_ULINT
 */
    case function_tod_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_ulint*/
    break;

/****
 *TOD_TO_INT
 */
    case function_tod_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__time_to_int"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_tod_to_int*/
    break;

/****
 *UDINT_TO_REAL
 */
    case function_udint_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_real*/
    break;

/****
 *UDINT_TO_SINT
 */
    case function_udint_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_sint*/
    break;

/****
 *UDINT_TO_LINT
 */
    case function_udint_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_lint*/
    break;

/****
 *UDINT_TO_DINT
 */
    case function_udint_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_dint*/
    break;

/****
 *UDINT_TO_DATE
 */
    case function_udint_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_date*/
    break;

/****
 *UDINT_TO_DWORD
 */
    case function_udint_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_dword*/
    break;

/****
 *UDINT_TO_DT
 */
    case function_udint_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_dt*/
    break;

/****
 *UDINT_TO_TOD
 */
    case function_udint_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_tod*/
    break;

/****
 *UDINT_TO_WORD
 */
    case function_udint_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_word*/
    break;

/****
 *UDINT_TO_STRING
 */
    case function_udint_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__uint_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_string*/
    break;

/****
 *UDINT_TO_LWORD
 */
    case function_udint_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_lword*/
    break;

/****
 *UDINT_TO_UINT
 */
    case function_udint_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_uint*/
    break;

/****
 *UDINT_TO_LREAL
 */
    case function_udint_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_lreal*/
    break;

/****
 *UDINT_TO_BYTE
 */
    case function_udint_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_byte*/
    break;

/****
 *UDINT_TO_USINT
 */
    case function_udint_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_usint*/
    break;

/****
 *UDINT_TO_ULINT
 */
    case function_udint_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_ulint*/
    break;

/****
 *UDINT_TO_BOOL
 */
    case function_udint_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_bool*/
    break;

/****
 *UDINT_TO_TIME
 */
    case function_udint_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_time*/
    break;

/****
 *UDINT_TO_INT
 */
    case function_udint_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_udint_to_int*/
    break;

/****
 *WORD_TO_REAL
 */
    case function_word_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_real*/
    break;

/****
 *WORD_TO_SINT
 */
    case function_word_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_sint*/
    break;

/****
 *WORD_TO_LINT
 */
    case function_word_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_lint*/
    break;

/****
 *WORD_TO_DINT
 */
    case function_word_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_dint*/
    break;

/****
 *WORD_TO_DATE
 */
    case function_word_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_date*/
    break;

/****
 *WORD_TO_DWORD
 */
    case function_word_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_dword*/
    break;

/****
 *WORD_TO_DT
 */
    case function_word_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_dt*/
    break;

/****
 *WORD_TO_TOD
 */
    case function_word_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_tod*/
    break;

/****
 *WORD_TO_UDINT
 */
    case function_word_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_udint*/
    break;

/****
 *WORD_TO_STRING
 */
    case function_word_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__bit_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_string*/
    break;

/****
 *WORD_TO_LWORD
 */
    case function_word_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_lword*/
    break;

/****
 *WORD_TO_UINT
 */
    case function_word_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_uint*/
    break;

/****
 *WORD_TO_LREAL
 */
    case function_word_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_lreal*/
    break;

/****
 *WORD_TO_BYTE
 */
    case function_word_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_byte*/
    break;

/****
 *WORD_TO_USINT
 */
    case function_word_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_usint*/
    break;

/****
 *WORD_TO_ULINT
 */
    case function_word_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_ulint*/
    break;

/****
 *WORD_TO_BOOL
 */
    case function_word_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_bool*/
    break;

/****
 *WORD_TO_TIME
 */
    case function_word_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_time*/
    break;

/****
 *WORD_TO_INT
 */
    case function_word_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_word_to_int*/
    break;

/****
 *STRING_TO_REAL
 */
    case function_string_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_real"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_real*/
    break;

/****
 *STRING_TO_SINT
 */
    case function_string_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_sint"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_sint*/
    break;

/****
 *STRING_TO_LINT
 */
    case function_string_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_sint"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_lint*/
    break;

/****
 *STRING_TO_DINT
 */
    case function_string_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_sint"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_dint*/
    break;

/****
 *STRING_TO_DATE
 */
    case function_string_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_date*/
    break;

/****
 *STRING_TO_DWORD
 */
    case function_string_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_bit"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_dword*/
    break;

/****
 *STRING_TO_DT
 */
    case function_string_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_dt*/
    break;

/****
 *STRING_TO_TOD
 */
    case function_string_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_tod*/
    break;

/****
 *STRING_TO_UDINT
 */
    case function_string_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_uint"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_udint*/
    break;

/****
 *STRING_TO_WORD
 */
    case function_string_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_bit"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_word*/
    break;

/****
 *STRING_TO_LWORD
 */
    case function_string_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_bit"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_lword*/
    break;

/****
 *STRING_TO_UINT
 */
    case function_string_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_uint"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_uint*/
    break;

/****
 *STRING_TO_LREAL
 */
    case function_string_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_real"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_lreal*/
    break;

/****
 *STRING_TO_BYTE
 */
    case function_string_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_bit"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_byte*/
    break;

/****
 *STRING_TO_USINT
 */
    case function_string_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_uint"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_usint*/
    break;

/****
 *STRING_TO_ULINT
 */
    case function_string_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_uint"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_ulint*/
    break;

/****
 *STRING_TO_BOOL
 */
    case function_string_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_bool"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_bool*/
    break;

/****
 *STRING_TO_TIME
 */
    case function_string_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_time*/
    break;

/****
 *STRING_TO_INT
 */
    case function_string_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__string_to_sint"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_string_to_int*/
    break;

/****
 *LWORD_TO_REAL
 */
    case function_lword_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_real*/
    break;

/****
 *LWORD_TO_SINT
 */
    case function_lword_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_sint*/
    break;

/****
 *LWORD_TO_LINT
 */
    case function_lword_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_lint*/
    break;

/****
 *LWORD_TO_DINT
 */
    case function_lword_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_dint*/
    break;

/****
 *LWORD_TO_DATE
 */
    case function_lword_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_date*/
    break;

/****
 *LWORD_TO_DWORD
 */
    case function_lword_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_dword*/
    break;

/****
 *LWORD_TO_DT
 */
    case function_lword_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_dt*/
    break;

/****
 *LWORD_TO_TOD
 */
    case function_lword_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_tod*/
    break;

/****
 *LWORD_TO_UDINT
 */
    case function_lword_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_udint*/
    break;

/****
 *LWORD_TO_WORD
 */
    case function_lword_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_word*/
    break;

/****
 *LWORD_TO_STRING
 */
    case function_lword_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__bit_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_string*/
    break;

/****
 *LWORD_TO_UINT
 */
    case function_lword_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_uint*/
    break;

/****
 *LWORD_TO_LREAL
 */
    case function_lword_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_lreal*/
    break;

/****
 *LWORD_TO_BYTE
 */
    case function_lword_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_byte*/
    break;

/****
 *LWORD_TO_USINT
 */
    case function_lword_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_usint*/
    break;

/****
 *LWORD_TO_ULINT
 */
    case function_lword_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_ulint*/
    break;

/****
 *LWORD_TO_BOOL
 */
    case function_lword_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_bool*/
    break;

/****
 *LWORD_TO_TIME
 */
    case function_lword_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_time*/
    break;

/****
 *LWORD_TO_INT
 */
    case function_lword_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lword_to_int*/
    break;

/****
 *UINT_TO_REAL
 */
    case function_uint_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_real*/
    break;

/****
 *UINT_TO_SINT
 */
    case function_uint_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_sint*/
    break;

/****
 *UINT_TO_LINT
 */
    case function_uint_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_lint*/
    break;

/****
 *UINT_TO_DINT
 */
    case function_uint_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_dint*/
    break;

/****
 *UINT_TO_DATE
 */
    case function_uint_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_date*/
    break;

/****
 *UINT_TO_DWORD
 */
    case function_uint_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_dword*/
    break;

/****
 *UINT_TO_DT
 */
    case function_uint_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_dt*/
    break;

/****
 *UINT_TO_TOD
 */
    case function_uint_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_tod*/
    break;

/****
 *UINT_TO_UDINT
 */
    case function_uint_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_udint*/
    break;

/****
 *UINT_TO_WORD
 */
    case function_uint_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_word*/
    break;

/****
 *UINT_TO_STRING
 */
    case function_uint_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__uint_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_string*/
    break;

/****
 *UINT_TO_LWORD
 */
    case function_uint_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_lword*/
    break;

/****
 *UINT_TO_LREAL
 */
    case function_uint_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_lreal*/
    break;

/****
 *UINT_TO_BYTE
 */
    case function_uint_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_byte*/
    break;

/****
 *UINT_TO_USINT
 */
    case function_uint_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_usint*/
    break;

/****
 *UINT_TO_ULINT
 */
    case function_uint_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_ulint*/
    break;

/****
 *UINT_TO_BOOL
 */
    case function_uint_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_bool*/
    break;

/****
 *UINT_TO_TIME
 */
    case function_uint_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_time*/
    break;

/****
 *UINT_TO_INT
 */
    case function_uint_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_uint_to_int*/
    break;

/****
 *LREAL_TO_REAL
 */
    case function_lreal_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_real*/
    break;

/****
 *LREAL_TO_SINT
 */
    case function_lreal_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_sint*/
    break;

/****
 *LREAL_TO_LINT
 */
    case function_lreal_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_lint*/
    break;

/****
 *LREAL_TO_DINT
 */
    case function_lreal_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_dint*/
    break;

/****
 *LREAL_TO_DATE
 */
    case function_lreal_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_date*/
    break;

/****
 *LREAL_TO_DWORD
 */
    case function_lreal_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_dword*/
    break;

/****
 *LREAL_TO_DT
 */
    case function_lreal_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_dt*/
    break;

/****
 *LREAL_TO_TOD
 */
    case function_lreal_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_tod*/
    break;

/****
 *LREAL_TO_UDINT
 */
    case function_lreal_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_udint*/
    break;

/****
 *LREAL_TO_WORD
 */
    case function_lreal_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_word*/
    break;

/****
 *LREAL_TO_STRING
 */
    case function_lreal_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_string*/
    break;

/****
 *LREAL_TO_LWORD
 */
    case function_lreal_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_lword*/
    break;

/****
 *LREAL_TO_UINT
 */
    case function_lreal_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_uint*/
    break;

/****
 *LREAL_TO_BYTE
 */
    case function_lreal_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_byte*/
    break;

/****
 *LREAL_TO_USINT
 */
    case function_lreal_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_usint*/
    break;

/****
 *LREAL_TO_ULINT
 */
    case function_lreal_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_ulint*/
    break;

/****
 *LREAL_TO_BOOL
 */
    case function_lreal_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_bool*/
    break;

/****
 *LREAL_TO_TIME
 */
    case function_lreal_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__real_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_time*/
    break;

/****
 *LREAL_TO_INT
 */
    case function_lreal_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_lreal_to_int*/
    break;

/****
 *BYTE_TO_REAL
 */
    case function_byte_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_real*/
    break;

/****
 *BYTE_TO_SINT
 */
    case function_byte_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_sint*/
    break;

/****
 *BYTE_TO_LINT
 */
    case function_byte_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_lint*/
    break;

/****
 *BYTE_TO_DINT
 */
    case function_byte_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_dint*/
    break;

/****
 *BYTE_TO_DATE
 */
    case function_byte_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_date*/
    break;

/****
 *BYTE_TO_DWORD
 */
    case function_byte_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_dword*/
    break;

/****
 *BYTE_TO_DT
 */
    case function_byte_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_dt*/
    break;

/****
 *BYTE_TO_TOD
 */
    case function_byte_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_tod*/
    break;

/****
 *BYTE_TO_UDINT
 */
    case function_byte_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_udint*/
    break;

/****
 *BYTE_TO_WORD
 */
    case function_byte_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_word*/
    break;

/****
 *BYTE_TO_STRING
 */
    case function_byte_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__bit_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_string*/
    break;

/****
 *BYTE_TO_LWORD
 */
    case function_byte_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_lword*/
    break;

/****
 *BYTE_TO_UINT
 */
    case function_byte_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_uint*/
    break;

/****
 *BYTE_TO_LREAL
 */
    case function_byte_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_lreal*/
    break;

/****
 *BYTE_TO_USINT
 */
    case function_byte_to_usint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_usint*/
    break;

/****
 *BYTE_TO_ULINT
 */
    case function_byte_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_ulint*/
    break;

/****
 *BYTE_TO_BOOL
 */
    case function_byte_to_bool :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_bool*/
    break;

/****
 *BYTE_TO_TIME
 */
    case function_byte_to_time :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_time*/
    break;

/****
 *BYTE_TO_INT
 */
    case function_byte_to_int :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_byte_to_int*/
    break;

/****
 *USINT_TO_REAL
 */
    case function_usint_to_real :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_real*/
    break;

/****
 *USINT_TO_SINT
 */
    case function_usint_to_sint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_sint*/
    break;

/****
 *USINT_TO_LINT
 */
    case function_usint_to_lint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_lint*/
    break;

/****
 *USINT_TO_DINT
 */
    case function_usint_to_dint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_dint*/
    break;

/****
 *USINT_TO_DATE
 */
    case function_usint_to_date :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_date*/
    break;

/****
 *USINT_TO_DWORD
 */
    case function_usint_to_dword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_dword*/
    break;

/****
 *USINT_TO_DT
 */
    case function_usint_to_dt :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_dt*/
    break;

/****
 *USINT_TO_TOD
 */
    case function_usint_to_tod :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__int_to_time"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_tod*/
    break;

/****
 *USINT_TO_UDINT
 */
    case function_usint_to_udint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_udint*/
    break;

/****
 *USINT_TO_WORD
 */
    case function_usint_to_word :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_word*/
    break;

/****
 *USINT_TO_STRING
 */
    case function_usint_to_string :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                function_name = (symbol_c*)(new pragma_c("__uint_to_string"));
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_string*/
    break;

/****
 *USINT_TO_LWORD
 */
    case function_usint_to_lword :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_lword*/
    break;

/****
 *USINT_TO_UINT
 */
    case function_usint_to_uint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_uint*/
    break;

/****
 *USINT_TO_LREAL
 */
    case function_usint_to_lreal :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_lreal*/
    break;

/****
 *USINT_TO_BYTE
 */
    case function_usint_to_byte :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();
            if (IN_param_value != NULL) {
              IN_type_symbol = search_expression_type->get_type(IN_param_value);
              last_type_symbol = last_type_symbol && IN_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 ;
            }
            
            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
            {
        
                
                if (IN_type_symbol == NULL)
                  IN_type_symbol = last_type_symbol;
                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
                function_type_prefix = return_type_symbol;
                break;
                
            }
            
            
            ERROR;
        }
        
    }/*function_usint_to_byte*/
    break;

/****
 *USINT_TO_ULINT
 */
    case function_usint_to_ulint :
    {
        symbol_c *last_type_symbol = NULL;

        {
            identifier_c param_name("IN");
            /* Get the value from a foo(<param_name> = <param_value>) style call */
            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
            symbol_c *IN_type_symbol = NULL;
            
            /* Get the value from a foo(<param_value>) style call */
            if (IN_param_value == NULL)
              IN_param_value = function_call_param_iterator.next();